@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/kernel/smart_patcher.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Smart Patcher — Line-Level Precision Patching Engine
+ *
+ * Pure functions for applying line-level patches to file content.
+ * Supports unified diff format parsing and structured PatchHunk application.
+ *
+ * @since v1.39.0
+ */
+export interface PatchLine {
+    op: 'context' | 'add' | 'remove';
+    content: string;
+}
+export interface PatchHunk {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: PatchLine[];
+}
+export interface PatchInstruction {
+    filePath: string;
+    hunks: PatchHunk[];
+}
+export interface PatchError {
+    type: 'CONTEXT_MISMATCH' | 'OVERLAP' | 'OUT_OF_RANGE' | 'EMPTY_HUNK' | 'MALFORMED';
+    hunkIndex: number;
+    line?: number;
+    expected?: string;
+    actual?: string;
+    message: string;
+}
+export interface PatchResult {
+    success: boolean;
+    content?: string;
+    errors: PatchError[];
+    hunksApplied: number;
+    linesAdded: number;
+    linesRemoved: number;
+}
+/**
+ * Validate hunks: sorted by oldStart, non-overlapping, counts match lines.
+ */
+export declare function validateHunks(hunks: PatchHunk[]): PatchError[];
+/**
+ * Apply hunks to file content. Hunks are applied bottom-up to avoid offset tracking.
+ */
+export declare function applyPatch(content: string, hunks: PatchHunk[]): PatchResult;
+/**
+ * Parse unified diff text into PatchHunk[].
+ * Returns null on parse failure.
+ */
+export declare function parseUnifiedDiff(diffText: string): PatchHunk[] | null;

package/build/kernel/smart_patcher.js

@@ -0,0 +1,221 @@
+/**
+ * Smart Patcher — Line-Level Precision Patching Engine
+ *
+ * Pure functions for applying line-level patches to file content.
+ * Supports unified diff format parsing and structured PatchHunk application.
+ *
+ * @since v1.39.0
+ */
+// ============================================================================
+// Validation
+// ============================================================================
+/**
+ * Validate hunks: sorted by oldStart, non-overlapping, counts match lines.
+ */
+export function validateHunks(hunks) {
+    const errors = [];
+    for (let i = 0; i < hunks.length; i++) {
+        const h = hunks[i];
+        if (h.oldStart < 1) {
+            errors.push({
+                type: 'OUT_OF_RANGE',
+                hunkIndex: i,
+                message: `Hunk ${i}: oldStart must be >= 1, got ${h.oldStart}`,
+            });
+        }
+        const contextAndRemove = h.lines.filter(l => l.op === 'context' || l.op === 'remove').length;
+        if (contextAndRemove !== h.oldCount) {
+            errors.push({
+                type: 'MALFORMED',
+                hunkIndex: i,
+                message: `Hunk ${i}: oldCount=${h.oldCount} but found ${contextAndRemove} context+remove lines`,
+            });
+        }
+        const contextAndAdd = h.lines.filter(l => l.op === 'context' || l.op === 'add').length;
+        if (contextAndAdd !== h.newCount) {
+            errors.push({
+                type: 'MALFORMED',
+                hunkIndex: i,
+                message: `Hunk ${i}: newCount=${h.newCount} but found ${contextAndAdd} context+add lines`,
+            });
+        }
+        const hasChange = h.lines.some(l => l.op === 'add' || l.op === 'remove');
+        if (h.lines.length > 0 && !hasChange) {
+            errors.push({
+                type: 'EMPTY_HUNK',
+                hunkIndex: i,
+                message: `Hunk ${i}: no add or remove operations (context-only)`,
+            });
+        }
+    }
+    // Check ordering and overlap
+    for (let i = 1; i < hunks.length; i++) {
+        const prev = hunks[i - 1];
+        const curr = hunks[i];
+        if (curr.oldStart < prev.oldStart) {
+            errors.push({
+                type: 'OVERLAP',
+                hunkIndex: i,
+                message: `Hunk ${i}: oldStart=${curr.oldStart} < previous hunk oldStart=${prev.oldStart} (not sorted)`,
+            });
+        }
+        else if (prev.oldStart + prev.oldCount > curr.oldStart) {
+            errors.push({
+                type: 'OVERLAP',
+                hunkIndex: i,
+                message: `Hunk ${i}: overlaps with hunk ${i - 1} (prev ends at line ${prev.oldStart + prev.oldCount - 1}, this starts at ${curr.oldStart})`,
+            });
+        }
+    }
+    return errors;
+}
+// ============================================================================
+// Patch Application
+// ============================================================================
+/**
+ * Apply hunks to file content. Hunks are applied bottom-up to avoid offset tracking.
+ */
+export function applyPatch(content, hunks) {
+    if (hunks.length === 0) {
+        return { success: true, content, errors: [], hunksApplied: 0, linesAdded: 0, linesRemoved: 0 };
+    }
+    const validationErrors = validateHunks(hunks);
+    if (validationErrors.length > 0) {
+        return {
+            success: false,
+            errors: validationErrors,
+            hunksApplied: 0,
+            linesAdded: 0,
+            linesRemoved: 0,
+        };
+    }
+    const lines = content.split('\n');
+    const errors = [];
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    // Sort by oldStart descending (bottom-up application)
+    const sorted = [...hunks].sort((a, b) => b.oldStart - a.oldStart);
+    for (const hunk of sorted) {
+        const originalIndex = hunks.indexOf(hunk);
+        // Range check
+        if (hunk.oldStart - 1 + hunk.oldCount > lines.length) {
+            errors.push({
+                type: 'OUT_OF_RANGE',
+                hunkIndex: originalIndex,
+                line: hunk.oldStart,
+                message: `Hunk ${originalIndex}: oldStart=${hunk.oldStart} + oldCount=${hunk.oldCount} exceeds file length (${lines.length} lines)`,
+            });
+            continue;
+        }
+        // Verify context and remove lines match original
+        let fileLineIdx = hunk.oldStart - 1;
+        let contextOk = true;
+        for (const patchLine of hunk.lines) {
+            if (patchLine.op === 'context' || patchLine.op === 'remove') {
+                const originalLine = lines[fileLineIdx];
+                if (originalLine !== patchLine.content) {
+                    errors.push({
+                        type: 'CONTEXT_MISMATCH',
+                        hunkIndex: originalIndex,
+                        line: fileLineIdx + 1,
+                        expected: patchLine.content,
+                        actual: originalLine,
+                        message: `Hunk ${originalIndex}: line ${fileLineIdx + 1} expected "${patchLine.content}" but got "${originalLine}"`,
+                    });
+                    contextOk = false;
+                    break;
+                }
+                fileLineIdx++;
+            }
+        }
+        if (!contextOk)
+            continue;
+        // Build replacement lines (context + add)
+        const replacement = [];
+        for (const patchLine of hunk.lines) {
+            if (patchLine.op === 'context' || patchLine.op === 'add') {
+                replacement.push(patchLine.content);
+            }
+        }
+        const added = hunk.lines.filter(l => l.op === 'add').length;
+        const removed = hunk.lines.filter(l => l.op === 'remove').length;
+        totalAdded += added;
+        totalRemoved += removed;
+        lines.splice(hunk.oldStart - 1, hunk.oldCount, ...replacement);
+    }
+    if (errors.length > 0) {
+        return { success: false, errors, hunksApplied: 0, linesAdded: 0, linesRemoved: 0 };
+    }
+    return {
+        success: true,
+        content: lines.join('\n'),
+        errors: [],
+        hunksApplied: hunks.length,
+        linesAdded: totalAdded,
+        linesRemoved: totalRemoved,
+    };
+}
+// ============================================================================
+// Unified Diff Parser
+// ============================================================================
+const HUNK_HEADER_RE = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/;
+/**
+ * Parse unified diff text into PatchHunk[].
+ * Returns null on parse failure.
+ */
+export function parseUnifiedDiff(diffText) {
+    const hunks = [];
+    const diffLines = diffText.split('\n');
+    let i = 0;
+    // Skip header lines (--- and +++ and index)
+    while (i < diffLines.length && !HUNK_HEADER_RE.test(diffLines[i])) {
+        i++;
+    }
+    while (i < diffLines.length) {
+        const match = HUNK_HEADER_RE.exec(diffLines[i]);
+        if (!match) {
+            i++;
+            continue;
+        }
+        const oldStart = parseInt(match[1], 10);
+        const oldCount = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+        const newStart = parseInt(match[3], 10);
+        const newCount = match[4] !== undefined ? parseInt(match[4], 10) : 1;
+        i++;
+        const lines = [];
+        while (i < diffLines.length && !HUNK_HEADER_RE.test(diffLines[i])) {
+            const line = diffLines[i];
+            if (line.startsWith('\\')) {
+                // "" — skip
+                i++;
+                continue;
+            }
+            if (line.startsWith('+')) {
+                lines.push({ op: 'add', content: line.slice(1) });
+            }
+            else if (line.startsWith('-')) {
+                lines.push({ op: 'remove', content: line.slice(1) });
+            }
+            else if (line.startsWith(' ')) {
+                lines.push({ op: 'context', content: line.slice(1) });
+            }
+            else if (line === '') {
+                // Could be end of diff or an empty context line
+                // Check if we've collected enough lines
+                const contextAndRemove = lines.filter(l => l.op === 'context' || l.op === 'remove').length;
+                if (contextAndRemove >= oldCount) {
+                    break;
+                }
+                // Treat as empty context line
+                lines.push({ op: 'context', content: '' });
+            }
+            else {
+                // Unrecognized line, end of hunk
+                break;
+            }
+            i++;
+        }
+        hunks.push({ oldStart, oldCount, newStart, newCount, lines });
+    }
+    return hunks.length > 0 ? hunks : null;
+}

package/build/kernel/sys_admin_types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Types for the sys_admin module — mirrors Rust `musu-worker::sys_admin::types`.
+ *
+ * These types are the TypeScript half of the Neural Bridge: Node.js uses them
+ * to build requests and parse responses from the Rust `/v1/sys/*` endpoints.
+ */
+export type SysCommand = {
+    type: 'system_info';
+} | {
+    type: 'process_list';
+} | {
+    type: 'disk_usage';
+    path?: string;
+} | {
+    type: 'service_status';
+    name: string;
+} | {
+    type: 'clean_logs';
+    older_than_days: number;
+    directory?: string;
+} | {
+    type: 'network_ports';
+};
+export type SysStatus = 'ok' | 'error' | 'denied';
+export interface SysAdminResponse {
+    status: SysStatus;
+    result: unknown;
+    duration_ms: number;
+    request_id: string;
+}
+export interface SysAdminRequest {
+    command: SysCommand;
+    request_id: string;
+}

package/build/kernel/sys_admin_types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the sys_admin module — mirrors Rust `musu-worker::sys_admin::types`.
+ *
+ * These types are the TypeScript half of the Neural Bridge: Node.js uses them
+ * to build requests and parse responses from the Rust `/v1/sys/*` endpoints.
+ */
+export {};

package/build/mapper-worker/client.js

@@ -5,6 +5,7 @@
  * Client for calling Mapper HTTP worker.
  * Supports single worker and pool modes with fallback to sync execution.
  */
+import { logger } from '../shared/logger.js';
 import { isMapperWorkerEnabled, isMapperPoolEnabled, getMapperWorkerUrl, getMapperTimeout, isMapperFallbackEnabled, } from "./types.js";
 // ============================================================
 // HTTP Client
@@ -237,7 +238,7 @@ let poolInitialized = false;
 export function getMapperClient() {
     if (!globalClient) {
         if (isMapperPoolEnabled() && !poolInitialized) {
-            console.log("[MapperClient] Pool mode enabled, but pool not initialized yet. Using single worker.");
+            logger.info("[MapperClient] Pool mode enabled, but pool not initialized yet. Using single worker.");
         }
         globalClient = new MapperWorkerClient();
     }
@@ -250,7 +251,7 @@ export function initPooledMapperClient(pool) {
     const client = new PooledMapperWorkerClient(pool);
     globalClient = client;
     poolInitialized = true;
-    console.log("[MapperClient] Pooled client initialized");
+    logger.info("[MapperClient] Pooled client initialized");
     return client;
 }
 /**
@@ -289,7 +290,7 @@ export async function diffScanViaWorkerOrFallback(workspaceRoot, runId, baseRef,
     catch (e) {
         const errorMsg = e instanceof Error ? e.message : String(e);
         if (client.shouldFallback()) {
-            console.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
+            logger.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
             try {
                 const data = fallbackFn();
                 return { success: true, data, usedWorker: false };
@@ -336,7 +337,7 @@ export async function stagedScanViaWorkerOrFallback(workspaceRoot, runId, fallba
     catch (e) {
         const errorMsg = e instanceof Error ? e.message : String(e);
         if (client.shouldFallback()) {
-            console.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
+            logger.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
             try {
                 const data = fallbackFn();
                 return { success: true, data, usedWorker: false };

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

@@ -5,7 +5,7 @@
  * 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";
+import type { MapperPoolOptions, MapperPoolHandle } from './types.js';
 /**
  * Create a mapper pool manager
  */

package/build/mapper-worker/pool.js

@@ -5,10 +5,10 @@
  * Manages a pool of mapper worker processes (4-16 workers).
  * Unlike BitNet workers, mapper workers are lightweight and can scale higher.
  */
-import { spawn } from "node:child_process";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getMapperOptionsFromEnv } from "./types.js";
+import { spawn } from 'node:child_process';
+import { getWorkerScriptPath } from '../kernel/paths.js';
+import { logger } from '../shared/logger.js';
+import { getMapperOptionsFromEnv } from './types.js';
 // ============================================================
 // Worker Binary Path
 // ============================================================
@@ -19,9 +19,7 @@ function findWorkerBinaryPath(customPath) {
     if (customPath) {
         return customPath;
     }
-    // Relative to this file: ../bin/vibe-mapper-worker.js (in build output)
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    return path.resolve(__dirname, "..", "bin", "vibe-mapper-worker.js");
+    return getWorkerScriptPath('vibe-mapper-worker');
 }
 // ============================================================
 // Health Check
@@ -58,7 +56,7 @@ async function waitForHealth(url, maxWaitMs = 5000, pollMs = 100) {
         if (health?.ok) {
             return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        await new Promise(resolve => setTimeout(resolve, pollMs));
     }
     return false;
 }
@@ -77,15 +75,15 @@ async function spawnWorker(state, port) {
         url,
         port,
         process: null,
-        status: "starting",
+        status: 'starting',
         lastHealth: null,
         lastHealthAt: 0,
     };
     state.workers.set(workerId, worker);
     state.usedPorts.add(port);
     try {
-        const proc = spawn("node", [workerPath, "--port", String(port)], {
-            stdio: ["ignore", "pipe", "pipe"],
+        const proc = spawn('node', [workerPath, '--port', String(port)], {
+            stdio: ['ignore', 'pipe', 'pipe'],
             detached: false,
             env: {
                 ...process.env,
@@ -93,46 +91,46 @@ async function spawnWorker(state, port) {
             },
         });
         worker.process = proc;
-        proc.on("exit", (code, signal) => {
-            if (process.env.VIBE_MAPPER_DEBUG === "1") {
-                console.log(`[MapperPool] Worker ${workerId} exited (code=${code}, signal=${signal})`);
+        proc.on('exit', (code, signal) => {
+            if (process.env.VIBE_MAPPER_DEBUG === '1') {
+                logger.info(`[MapperPool] Worker ${workerId} exited (code=${code}, signal=${signal})`);
             }
-            worker.status = "unhealthy";
+            worker.status = 'unhealthy';
             worker.process = null;
         });
-        proc.on("error", (err) => {
-            console.error(`[MapperPool] Worker ${workerId} error:`, err.message);
-            worker.status = "unhealthy";
+        proc.on('error', err => {
+            logger.error(`[MapperPool] Worker ${workerId} error: ${err.message}`);
+            worker.status = 'unhealthy';
         });
         // Debug logging
-        if (process.env.VIBE_MAPPER_DEBUG === "1") {
-            proc.stdout?.on("data", (data) => {
-                console.log(`[Mapper ${port}] ${data.toString().trim()}`);
+        if (process.env.VIBE_MAPPER_DEBUG === '1') {
+            proc.stdout?.on('data', data => {
+                logger.info(`[Mapper ${port}] ${data.toString().trim()}`);
             });
-            proc.stderr?.on("data", (data) => {
-                console.error(`[Mapper ${port}] ${data.toString().trim()}`);
+            proc.stderr?.on('data', data => {
+                logger.error(`[Mapper ${port}] ${data.toString().trim()}`);
             });
         }
         // Wait for healthy
         const isHealthy = await waitForHealth(url, 5000);
         if (isHealthy) {
-            worker.status = "healthy";
+            worker.status = 'healthy';
             worker.lastHealthAt = Date.now();
-            if (process.env.VIBE_MAPPER_DEBUG === "1") {
-                console.log(`[MapperPool] Worker ${workerId} is healthy at ${url}`);
+            if (process.env.VIBE_MAPPER_DEBUG === '1') {
+                logger.info(`[MapperPool] Worker ${workerId} is healthy at ${url}`);
             }
             return worker;
         }
         else {
-            console.error(`[MapperPool] Worker ${workerId} failed health check`);
-            proc.kill("SIGTERM");
-            worker.status = "unhealthy";
+            logger.error(`[MapperPool] Worker ${workerId} failed health check`);
+            proc.kill('SIGTERM');
+            worker.status = 'unhealthy';
             return null;
         }
     }
     catch (err) {
-        console.error(`[MapperPool] Failed to spawn worker ${workerId}:`, err);
-        worker.status = "unhealthy";
+        logger.error({ err }, `[MapperPool] Failed to spawn worker ${workerId}`);
+        worker.status = 'unhealthy';
         state.usedPorts.delete(port);
         state.workers.delete(workerId);
         return null;
@@ -145,18 +143,18 @@ async function killWorker(worker) {
     if (!worker.process) {
         return;
     }
-    worker.status = "stopping";
-    return new Promise((resolve) => {
+    worker.status = 'stopping';
+    return new Promise(resolve => {
         const proc = worker.process;
         const timeout = setTimeout(() => {
-            proc.kill("SIGKILL");
+            proc.kill('SIGKILL');
             resolve();
         }, 3000);
-        proc.once("exit", () => {
+        proc.once('exit', () => {
             clearTimeout(timeout);
             resolve();
         });
-        proc.kill("SIGTERM");
+        proc.kill('SIGTERM');
     });
 }
 // ============================================================
@@ -170,11 +168,11 @@ async function pollHealth(state) {
         const health = await fetchHealth(worker.url);
         worker.lastHealthAt = Date.now();
         if (health?.ok) {
-            worker.status = "healthy";
+            worker.status = 'healthy';
             worker.lastHealth = health;
         }
-        else if (worker.status === "healthy") {
-            worker.status = "unhealthy";
+        else if (worker.status === 'healthy') {
+            worker.status = 'unhealthy';
         }
     });
     await Promise.all(promises);
@@ -191,7 +189,7 @@ export function createMapperPool(opts) {
         poolSize: opts?.poolSize ?? envOpts.poolSize ?? 4,
         basePort: opts?.basePort ?? envOpts.basePort ?? 8850,
         healthPollMs: opts?.healthPollMs ?? envOpts.healthPollMs ?? 1000,
-        workerBinaryPath: opts?.workerBinaryPath ?? "",
+        workerBinaryPath: opts?.workerBinaryPath ?? '',
     };
     const state = {
         workers: new Map(),
@@ -206,7 +204,7 @@ export function createMapperPool(opts) {
     const handle = {
         workers: state.workers,
         getHealthyWorkers() {
-            return Array.from(state.workers.values()).filter((w) => w.status === "healthy");
+            return Array.from(state.workers.values()).filter(w => w.status === 'healthy');
         },
         selectWorker() {
             const healthy = this.getHealthyWorkers();
@@ -222,7 +220,7 @@ export function createMapperPool(opts) {
                 return;
             }
             state.running = true;
-            console.log(`[MapperPool] Starting pool with ${options.poolSize} workers`);
+            logger.info(`[MapperPool] Starting pool with ${options.poolSize} workers`);
             // Spawn workers in parallel
             const spawnPromises = [];
             for (let i = 0; i < options.poolSize; i++) {
@@ -235,14 +233,14 @@ export function createMapperPool(opts) {
                 await pollHealth(state);
             }, options.healthPollMs);
             const healthyCount = this.getHealthyWorkers().length;
-            console.log(`[MapperPool] Pool started with ${healthyCount}/${options.poolSize} healthy workers`);
+            logger.info(`[MapperPool] Pool started with ${healthyCount}/${options.poolSize} healthy workers`);
         },
         async shutdown() {
             if (!state.running) {
                 return;
             }
             state.running = false;
-            console.log("[MapperPool] Shutting down pool...");
+            logger.info('[MapperPool] Shutting down pool...');
             // Stop health polling
             if (state.healthInterval) {
                 clearInterval(state.healthInterval);
@@ -250,12 +248,12 @@ export function createMapperPool(opts) {
             }
             // Kill all workers
             const killPromises = Array.from(state.workers.values())
-                .filter((w) => w.process !== null)
-                .map((w) => killWorker(w));
+                .filter(w => w.process !== null)
+                .map(w => killWorker(w));
             await Promise.all(killPromises);
             state.workers.clear();
             state.usedPorts.clear();
-            console.log("[MapperPool] Pool shut down");
+            logger.info('[MapperPool] Pool shut down');
         },
         isRunning() {
             return state.running;
@@ -280,7 +278,7 @@ export function getMapperPool() {
  * Start global pool if pool mode is enabled
  */
 export async function startMapperPoolIfEnabled() {
-    const { isMapperPoolEnabled } = await import("./types.js");
+    const { isMapperPoolEnabled } = await import('./types.js');
     if (!isMapperPoolEnabled()) {
         return null;
     }

package/build/mapper-worker/server.js

@@ -12,6 +12,7 @@
  */
 import { createServer } from "node:http";
 import { spawn } from "node:child_process";
+import { logger } from '../shared/logger.js';
 import { createLivenessHandler, createReadinessHandler, gitAvailableChecker, queueHealthChecker, } from "../health/index.js";
 const metrics = {
     startTime: Date.now(),
@@ -201,18 +202,16 @@ async function handleScan(req, res) {
                 result = { files, base_ref: "staged", head_ref: "working" };
                 break;
             }
-            case "import_scan":
-            case "full_pipeline":
-                // These would require more complex implementation
-                // For now, return not implemented
+            default: {
                 const response = {
                     ok: false,
                     type: request.type,
-                    error: `Operation ${request.type} not yet implemented`,
+                    error: `Unknown operation: ${request.type}`,
                 };
-                res.writeHead(501, { "Content-Type": "application/json" });
+                res.writeHead(400, { "Content-Type": "application/json" });
                 res.end(JSON.stringify(response));
                 return;
+            }
         }
         const duration = Date.now() - startTime;
         metrics.totalRequests++;
@@ -289,7 +288,7 @@ export function startMapperWorkerServer(options) {
             }
         }
         catch (error) {
-            console.error("[MapperWorker] Request error:", error);
+            logger.error({ err: error }, "[MapperWorker] Request error");
             res.writeHead(500, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
                 error: error instanceof Error ? error.message : "Internal error",
@@ -297,7 +296,7 @@ export function startMapperWorkerServer(options) {
         }
     });
     server.listen(port, host, () => {
-        console.log(`[MapperWorker] Listening on http://${host}:${port}`);
+        logger.info(`[MapperWorker] Listening on http://${host}:${port}`);
     });
     // Reset metrics on start
     metrics.startTime = Date.now();