@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/workers/base/health.js

@@ -3,8 +3,9 @@
  *
  * Phase 17: Health monitoring and auto-recovery for workers
  */
-import * as fs from 'fs';
 import * as path from 'path';
+import { readdir, readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { existsAsync } from '../../kernel/async-fs.js';
 const DEFAULT_CONFIG = {
     stuck_task_threshold_ms: 5 * 60 * 1000, // 5 minutes
     min_disk_space_mb: 100,
@@ -39,12 +40,12 @@ export class HealthChecker {
     async check() {
         const issues = [];
         // Check queue accessibility
-        const queueAccessible = this.checkQueueAccessible();
+        const queueAccessible = await this.checkQueueAccessible();
         if (!queueAccessible) {
             issues.push('Queue directory is not accessible');
         }
         // Check disk space
-        const diskSpaceOk = this.checkDiskSpace();
+        const diskSpaceOk = await this.checkDiskSpace();
         if (!diskSpaceOk) {
             issues.push(`Disk space below ${this.config.min_disk_space_mb}MB threshold`);
         }
@@ -124,19 +125,19 @@ export class HealthChecker {
      */
     async getStuckTasks() {
         const claimedDir = this.getQueuePath('claimed');
-        if (!fs.existsSync(claimedDir)) {
+        if (!(await existsAsync(claimedDir))) {
             return [];
         }
         const stuckTasks = [];
         const now = Date.now();
         const threshold = this.config.stuck_task_threshold_ms;
         try {
-            const files = fs.readdirSync(claimedDir);
+            const files = await readdir(claimedDir);
             for (const file of files) {
                 if (!file.endsWith('.json'))
                     continue;
                 const filePath = path.join(claimedDir, file);
-                const content = fs.readFileSync(filePath, 'utf-8');
+                const content = await readFile(filePath, 'utf-8');
                 const task = JSON.parse(content);
                 if (task.claimed_at) {
                     const claimedTime = new Date(task.claimed_at).getTime();
@@ -154,35 +155,31 @@ export class HealthChecker {
     // ==========================================================================
     // Private Methods
     // ==========================================================================
-    checkQueueAccessible() {
+    async checkQueueAccessible() {
         const queueDir = path.join(this.vibeDir, 'runs', this.runId, 'queue');
         try {
-            if (!fs.existsSync(queueDir)) {
-                fs.mkdirSync(queueDir, { recursive: true });
+            if (!(await existsAsync(queueDir))) {
+                await mkdir(queueDir, { recursive: true });
             }
-            // Test write access
             const testFile = path.join(queueDir, '.health-check');
-            fs.writeFileSync(testFile, 'test');
-            fs.unlinkSync(testFile);
+            await writeFile(testFile, 'test');
+            await unlink(testFile);
             return true;
         }
         catch {
             return false;
         }
     }
-    checkDiskSpace() {
-        // Simplified disk space check
-        // In production, use statvfs or similar
+    async checkDiskSpace() {
         try {
             const queueDir = path.join(this.vibeDir, 'runs', this.runId, 'queue');
-            if (!fs.existsSync(queueDir)) {
-                fs.mkdirSync(queueDir, { recursive: true });
+            if (!(await existsAsync(queueDir))) {
+                await mkdir(queueDir, { recursive: true });
             }
-            // Try to write a test file
             const testFile = path.join(queueDir, '.disk-check');
-            const testData = Buffer.alloc(1024); // 1KB
-            fs.writeFileSync(testFile, testData);
-            fs.unlinkSync(testFile);
+            const testData = Buffer.alloc(1024);
+            await writeFile(testFile, testData);
+            await unlink(testFile);
             return true;
         }
         catch {
@@ -194,31 +191,26 @@ export class HealthChecker {
     }
     async recoverTask(task) {
         const claimedPath = path.join(this.getQueuePath('claimed'), `${task.task_id}.json`);
-        // Check retry count
-        const retryCount = task.retry_count || 0;
+        const retryCount = this.getRetryCount(task);
         if (retryCount >= this.config.max_retries) {
-            // Move to failed instead of pending
             const failedPath = path.join(this.getQueuePath('failed'), `${task.task_id}.json`);
-            // Ensure failed directory exists
             const failedDir = this.getQueuePath('failed');
-            if (!fs.existsSync(failedDir)) {
-                fs.mkdirSync(failedDir, { recursive: true });
+            if (!(await existsAsync(failedDir))) {
+                await mkdir(failedDir, { recursive: true });
             }
             const failedTask = {
                 ...task,
                 status: 'failed',
                 error: `Task exceeded max retries (${this.config.max_retries})`,
             };
-            fs.writeFileSync(failedPath, JSON.stringify(failedTask, null, 2));
-            fs.unlinkSync(claimedPath);
+            await writeFile(failedPath, JSON.stringify(failedTask, null, 2));
+            await unlink(claimedPath);
             return true;
         }
-        // Move back to pending
         const pendingPath = path.join(this.getQueuePath('pending'), `${task.task_id}.json`);
-        // Ensure pending directory exists
         const pendingDir = this.getQueuePath('pending');
-        if (!fs.existsSync(pendingDir)) {
-            fs.mkdirSync(pendingDir, { recursive: true });
+        if (!(await existsAsync(pendingDir))) {
+            await mkdir(pendingDir, { recursive: true });
         }
         const pendingTask = {
             ...task,
@@ -227,10 +219,14 @@ export class HealthChecker {
             claimed_at: undefined,
             retry_count: retryCount + 1,
         };
-        fs.writeFileSync(pendingPath, JSON.stringify(pendingTask, null, 2));
-        fs.unlinkSync(claimedPath);
+        await writeFile(pendingPath, JSON.stringify(pendingTask, null, 2));
+        await unlink(claimedPath);
         return true;
     }
+    getRetryCount(task) {
+        const value = task.retry_count;
+        return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+    }
 }
 /**
  * Create a pre-configured health checker

package/build/workers/base/pool.js

@@ -4,6 +4,7 @@
  * Phase 18: Manages a pool of worker instances for efficient resource utilization
  */
 import { createWorker } from '../index.js';
+import { logger } from '../../shared/logger.js';
 const DEFAULT_CONFIG = {
     workerType: 'fs',
     minWorkers: 1,
@@ -239,7 +240,7 @@ export class WorkerPool {
         this.workers.set(id, pooled);
         // Start worker in background
         worker.start().catch(err => {
-            console.error(`[WorkerPool] Worker ${id} error:`, err);
+            logger.error({ err }, `[WorkerPool] Worker ${id} error`);
             this.workers.delete(id);
         });
         return worker;

package/build/workers/base/queue.d.ts

@@ -4,6 +4,13 @@
  * Manages task queue with pending → claimed → done/failed states
  */
 import { WorkerTask, TaskStatus, WorkerType } from './types.js';
+/** Queue operation metrics */
+export interface QueueMetrics {
+    claim_success: number;
+    claim_conflict: number;
+    move_success: number;
+    move_error: number;
+}
 /** Queue paths configuration */
 export interface QueuePaths {
     base: string;
@@ -13,14 +20,29 @@ export interface QueuePaths {
     failed: string;
     canceled: string;
 }
+/** Queue manager interface for DI / test mocking */
+export interface IQueueManager {
+    addTask(task: WorkerTask): Promise<void>;
+    getPendingTasks(workerType: WorkerType): Promise<WorkerTask[]>;
+    claimTask(taskId: string): Promise<WorkerTask | null>;
+    completeTask(taskId: string): Promise<void>;
+    failTask(taskId: string): Promise<void>;
+    cancelTask(taskId: string): Promise<void>;
+    getTask(taskId: string): Promise<WorkerTask | null>;
+    getStats(): Promise<Record<TaskStatus, number>>;
+    getMetrics(): QueueMetrics;
+}
 /**
  * Queue Manager
  * Handles task queue operations with file-based storage
  */
-export declare class QueueManager {
+export declare class QueueManager implements IQueueManager {
     private paths;
     private workerId;
-    constructor(runId: string, workerId: string);
+    private metrics;
+    constructor(runId: string, workerId: string, vibeDir?: string);
+    /** Get queue operation metrics */
+    getMetrics(): QueueMetrics;
     /** Ensure all queue directories exist */
     private ensureDirectories;
     /** Get task file path */
@@ -35,9 +57,9 @@ export declare class QueueManager {
     completeTask(taskId: string): Promise<void>;
     /** Mark task as failed */
     failTask(taskId: string): Promise<void>;
-    /** Cancel a task */
+    /** Cancel a task (try pending first, then claimed) */
     cancelTask(taskId: string): Promise<void>;
-    /** Move task between statuses */
+    /** Move task between statuses (atomic rename) */
     private moveTask;
     /** Get task by ID from any queue */
     getTask(taskId: string): Promise<WorkerTask | null>;

package/build/workers/base/queue.js

@@ -12,9 +12,10 @@ import * as path from 'path';
 export class QueueManager {
     paths;
     workerId;
-    constructor(runId, workerId) {
-        const vibeDir = process.env.VIBE_DIR || '.vibe';
-        const base = path.join(vibeDir, 'runs', runId, 'queue');
+    metrics = { claim_success: 0, claim_conflict: 0, move_success: 0, move_error: 0 };
+    constructor(runId, workerId, vibeDir) {
+        const resolvedVibeDir = vibeDir || process.env.VIBE_DIR || '.vibe';
+        const base = path.join(resolvedVibeDir, 'runs', runId, 'queue');
         this.paths = {
             base,
             pending: path.join(base, 'pending'),
@@ -26,6 +27,10 @@ export class QueueManager {
         this.workerId = workerId;
         this.ensureDirectories();
     }
+    /** Get queue operation metrics */
+    getMetrics() {
+        return { ...this.metrics };
+    }
     /** Ensure all queue directories exist */
     ensureDirectories() {
         Object.values(this.paths).forEach(dir => {
@@ -53,10 +58,17 @@ export class QueueManager {
         for (const file of files) {
             if (!file.endsWith('.json'))
                 continue;
-            const content = fs.readFileSync(path.join(this.paths.pending, file), 'utf-8');
-            const task = JSON.parse(content);
-            if (task.worker_type === workerType) {
-                tasks.push(task);
+            const pendingPath = path.join(this.paths.pending, file);
+            try {
+                const content = fs.readFileSync(pendingPath, 'utf-8');
+                const task = JSON.parse(content);
+                if (task.worker_type === workerType) {
+                    tasks.push(task);
+                }
+            }
+            catch {
+                // Best-effort queue scan: file may be moved/removed concurrently.
+                continue;
             }
         }
         // Sort by priority and creation time
@@ -73,24 +85,22 @@ export class QueueManager {
     async claimTask(taskId) {
         const pendingPath = this.getTaskPath(taskId, 'pending');
         const claimedPath = this.getTaskPath(taskId, 'claimed');
-        if (!fs.existsSync(pendingPath)) {
-            return null; // Already claimed by another worker
-        }
         try {
-            // Read task
-            const content = fs.readFileSync(pendingPath, 'utf-8');
+            // Atomic rename — exactly one worker wins, others get ENOENT
+            fs.renameSync(pendingPath, claimedPath);
+            // Winner: read-modify-write the moved file
+            const content = fs.readFileSync(claimedPath, 'utf-8');
             const task = JSON.parse(content);
-            // Update task
             task.status = 'claimed';
             task.claimed_by = this.workerId;
             task.claimed_at = new Date().toISOString();
-            // Atomic move (write then delete)
             fs.writeFileSync(claimedPath, JSON.stringify(task, null, 2));
-            fs.unlinkSync(pendingPath);
+            this.metrics.claim_success++;
             return task;
         }
-        catch (error) {
-            // Race condition - another worker claimed it
+        catch {
+            // rename failed = another worker already claimed it
+            this.metrics.claim_conflict++;
             return null;
         }
     }
@@ -102,28 +112,39 @@ export class QueueManager {
     async failTask(taskId) {
         await this.moveTask(taskId, 'claimed', 'failed');
     }
-    /** Cancel a task */
+    /** Cancel a task (try pending first, then claimed) */
     async cancelTask(taskId) {
-        // Try to cancel from pending first
-        if (fs.existsSync(this.getTaskPath(taskId, 'pending'))) {
+        try {
             await this.moveTask(taskId, 'pending', 'canceled');
+            return;
         }
-        else if (fs.existsSync(this.getTaskPath(taskId, 'claimed'))) {
+        catch {
+            // Not in pending — try claimed
+        }
+        try {
             await this.moveTask(taskId, 'claimed', 'canceled');
         }
+        catch {
+            // Already moved or not found
+        }
     }
-    /** Move task between statuses */
+    /** Move task between statuses (atomic rename) */
     async moveTask(taskId, from, to) {
         const fromPath = this.getTaskPath(taskId, from);
         const toPath = this.getTaskPath(taskId, to);
-        if (!fs.existsSync(fromPath)) {
-            throw new Error(`Task ${taskId} not found in ${from} queue`);
+        try {
+            // Atomic rename — fails with ENOENT if already moved
+            fs.renameSync(fromPath, toPath);
+            const content = fs.readFileSync(toPath, 'utf-8');
+            const task = JSON.parse(content);
+            task.status = to;
+            fs.writeFileSync(toPath, JSON.stringify(task, null, 2));
+            this.metrics.move_success++;
+        }
+        catch (e) {
+            this.metrics.move_error++;
+            throw e;
         }
-        const content = fs.readFileSync(fromPath, 'utf-8');
-        const task = JSON.parse(content);
-        task.status = to;
-        fs.writeFileSync(toPath, JSON.stringify(task, null, 2));
-        fs.unlinkSync(fromPath);
     }
     /** Get task by ID from any queue */
     async getTask(taskId) {

package/build/workers/base/worker.js

@@ -6,10 +6,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { QueueManager, createWorkerId } from './queue.js';
-import { appendEventLog } from "../../mcp/events/logger.js";
-import { randomUUID } from "node:crypto";
-import { resolveRelativePosix } from "../../mcp/path-utils.js";
-import { getVibeDir } from "../../mcp/paths.js";
+import { appendEventLog } from '../../mcp/events/logger.js';
+import { randomUUID } from 'node:crypto';
+import { logger } from '../../shared/logger.js';
+import { resolveRelativePosix } from '../../mcp/path-utils.js';
+import { getVibeDir } from '../../kernel/paths.js';
 /**
  * Abstract Base Worker
  * All workers must extend this class
@@ -28,12 +29,12 @@ export class BaseWorker {
             ...config,
         };
         this.workerId = createWorkerId(config.type);
-        this.queue = new QueueManager(config.runId, this.workerId);
+        this.queue = new QueueManager(config.runId, this.workerId, this.config.artifactDir);
     }
     /** Start the worker */
     async start() {
         this.running = true;
-        console.log(`[${this.name}] Worker ${this.workerId} started`);
+        logger.info(`[${this.name}] Worker ${this.workerId} started`);
         while (this.running) {
             await this.processNextTask();
             await this.sleep(this.config.pollInterval);
@@ -42,12 +43,12 @@ export class BaseWorker {
     /** Stop the worker */
     async stop() {
         this.running = false;
-        console.log(`[${this.name}] Worker ${this.workerId} stopping...`);
+        logger.info(`[${this.name}] Worker ${this.workerId} stopping...`);
         // Wait for current tasks to complete
         while (this.currentTasks.size > 0) {
             await this.sleep(100);
         }
-        console.log(`[${this.name}] Worker ${this.workerId} stopped`);
+        logger.info(`[${this.name}] Worker ${this.workerId} stopped`);
     }
     /** Process next available task */
     async processNextTask() {
@@ -84,7 +85,7 @@ export class BaseWorker {
                 const timestamp = new Date().toISOString();
                 const line = `[${timestamp}] ${message}`;
                 logs.push(line);
-                console.log(`[${this.name}:${task.task_id}] ${message}`);
+                logger.info(`[${this.name}:${task.task_id}] ${message}`);
             },
         };
         this.currentTasks.set(task.task_id, ctx);
@@ -109,8 +110,20 @@ export class BaseWorker {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             ctx.log(`Task failed: ${errorMessage}`);
+            // Ensure artifact directory exists before writing
+            try {
+                fs.mkdirSync(artifactDir, { recursive: true });
+            }
+            catch {
+                // Ignore mkdir errors
+            }
             // Save error artifacts
-            fs.writeFileSync(logPath, logs.join('\n'));
+            try {
+                fs.writeFileSync(logPath, logs.join('\n'));
+            }
+            catch {
+                // Ignore write errors (best effort)
+            }
             const result = this.buildResult(task, 'failure', startTime, {}, artifactDir, errorMessage);
             this.saveResult(task, result);
             this.emitResultEvent(task, resultPath);
@@ -126,18 +139,23 @@ export class BaseWorker {
         try {
             const workspaceRoot = process.cwd();
             const rel = resolveRelativePosix(workspaceRoot, resultPath);
-            const logPath = path.join(getVibeDir(workspaceRoot), "runs", task.run_id, "events.jsonl");
+            const logPath = path.join(getVibeDir(workspaceRoot), 'runs', task.run_id, 'events.jsonl');
             const event = {
-                schema_version: "event.v1",
+                schema_version: 'event.v1',
                 event_id: randomUUID(),
                 ts: new Date().toISOString(),
                 run_id: task.run_id,
-                type: "artifact.result_written",
-                reason: "worker_completed",
-                source: { actor: "worker", component: this.name },
+                type: 'artifact.result_written',
+                reason: 'worker_completed',
+                source: { actor: 'worker', component: this.name },
                 refs: { paths: [rel], task_id: task.task_id },
             };
-            appendEventLog(logPath, { status: "handled", event, ts: new Date().toISOString(), message: "worker result" });
+            appendEventLog(logPath, {
+                status: 'handled',
+                event,
+                ts: new Date().toISOString(),
+                message: 'worker result',
+            });
         }
         catch (e) {
             // best-effort; ignore

package/build/workers/browser/index.js

@@ -28,7 +28,7 @@ export class BrowserWorker extends BaseWorker {
             return;
         try {
             // Dynamic import - playwright is an optional peer dependency
-            // @ts-ignore - playwright may not be installed
+            // @ts-expect-error playwright is an optional peer dependency
             this.playwright = await import('playwright');
             ctx.log('Launching browser...');
             this.browser = await this.playwright.chromium.launch({

package/build/workers/index.js

@@ -20,6 +20,7 @@ export { ModelWorker, _createModelWorker as createModelWorker };
 export { BrowserWorker, _createBrowserWorker as createBrowserWorker };
 export { BuildWorker, _createBuildWorker as createBuildWorker };
 export { SearchWorker, _createSearchWorker as createSearchWorker };
+import { logger } from '../shared/logger.js';
 /**
  * Create worker by type
  */
@@ -46,12 +47,12 @@ export async function runWorker(type, runId) {
     const worker = createWorker(type, runId);
     // Handle shutdown signals
     process.on('SIGINT', async () => {
-        console.log('\nReceived SIGINT, stopping worker...');
+        logger.info('Received SIGINT, stopping worker...');
         await worker.stop();
         process.exit(0);
     });
     process.on('SIGTERM', async () => {
-        console.log('\nReceived SIGTERM, stopping worker...');
+        logger.info('Received SIGTERM, stopping worker...');
         await worker.stop();
         process.exit(0);
     });

package/build/workers/manager.d.ts

@@ -107,6 +107,7 @@ export interface WorkerManagerConfig {
  */
 export declare class WorkerManager {
     private static instance;
+    private static shutdownHandlersInstalled;
     /** Running workers by `${type}-${runId}` */
     private workers;
     /** Queue managers by runId */

package/build/workers/manager.js

@@ -11,6 +11,7 @@ import { WorkerPool } from './base/pool.js';
 import { Autoscaler } from './base/autoscaler.js';
 import { Dashboard } from './base/dashboard.js';
 import { createWorker } from './index.js';
+import { logger } from '../shared/logger.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -56,6 +57,7 @@ const DEFAULT_CONFIG = {
  */
 export class WorkerManager {
     static instance = null;
+    static shutdownHandlersInstalled = false;
     /** Running workers by `${type}-${runId}` */
     workers = new Map();
     /** Queue managers by runId */
@@ -74,6 +76,7 @@ export class WorkerManager {
     taskCounter = 0;
     constructor(config) {
         this.config = { ...DEFAULT_CONFIG, ...config };
+        process.env.VIBE_DIR = this.config.vibeDir;
         this.setupShutdownHandlers();
     }
     /**
@@ -258,7 +261,7 @@ export class WorkerManager {
      * Graceful shutdown of all workers
      */
     async shutdown() {
-        console.log('[WorkerManager] Shutting down...');
+        logger.info('[WorkerManager] Shutting down...');
         // Clear all idle timers
         for (const timer of this.idleTimers.values()) {
             clearTimeout(timer);
@@ -279,14 +282,14 @@ export class WorkerManager {
         // Stop all workers
         const stopPromises = [];
         for (const [key, worker] of this.workers.entries()) {
-            console.log(`[WorkerManager] Stopping worker: ${key}`);
+            logger.info(`[WorkerManager] Stopping worker: ${key}`);
             stopPromises.push(worker.stop());
         }
         await Promise.all(stopPromises);
         this.workers.clear();
         this.queues.clear();
         this.dashboards.clear();
-        console.log('[WorkerManager] Shutdown complete');
+        logger.info('[WorkerManager] Shutdown complete');
     }
     // ==========================================================================
     // Pool & Autoscaler API
@@ -425,7 +428,7 @@ export class WorkerManager {
     ensureQueue(runId) {
         if (!this.queues.has(runId)) {
             const workerId = `manager-${Date.now().toString(36)}`;
-            this.queues.set(runId, new QueueManager(runId, workerId));
+            this.queues.set(runId, new QueueManager(runId, workerId, this.config.vibeDir));
         }
         return this.queues.get(runId);
     }
@@ -465,12 +468,13 @@ export class WorkerManager {
             dashboard.updateWorkerStatus(workerKey, 'active');
         }
         if (!this.workers.has(workerKey)) {
-            console.log(`[WorkerManager] Starting worker: ${workerKey}`);
+            logger.info(`[WorkerManager] Starting worker: ${workerKey}`);
+            process.env.VIBE_DIR = this.config.vibeDir;
             const worker = createWorker(type, runId);
             this.workers.set(workerKey, worker);
             // Start worker in background
             worker.start().catch(err => {
-                console.error(`[WorkerManager] Worker ${workerKey} error:`, err);
+                logger.error({ err }, `[WorkerManager] Worker ${workerKey} error`);
                 this.workers.delete(workerKey);
                 // Update dashboard status
                 if (this.config.enableDashboard) {
@@ -494,7 +498,7 @@ export class WorkerManager {
         }
         // Set new timer
         const timer = setTimeout(async () => {
-            console.log(`[WorkerManager] Idle timeout for worker: ${workerKey}`);
+            logger.info(`[WorkerManager] Idle timeout for worker: ${workerKey}`);
             const worker = this.workers.get(workerKey);
             if (worker) {
                 await worker.stop();
@@ -549,11 +553,17 @@ export class WorkerManager {
      * Setup process shutdown handlers
      */
     setupShutdownHandlers() {
-        const handler = async () => {
-            await this.shutdown();
+        if (WorkerManager.shutdownHandlersInstalled) {
+            return;
+        }
+        const handler = () => {
+            if (WorkerManager.instance) {
+                void WorkerManager.instance.shutdown();
+            }
         };
         process.on('SIGINT', handler);
         process.on('SIGTERM', handler);
+        WorkerManager.shutdownHandlersInstalled = true;
     }
 }
 // Export singleton getter

package/build/workers/search/index.d.ts

@@ -58,6 +58,10 @@ export interface SearchWorkerOutput {
     type: string;
     totalResults: number;
     results: SearchResult[];
+    /** Placeholder flag for unimplemented search types (e.g. web) */
+    _placeholder?: boolean;
+    /** Human-readable message (e.g. for placeholder responses) */
+    message?: string;
     evidence: {
         searchUrl: string;
         timestamp: string;