monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/services/worker-daemon.js

@@ -10,7 +10,7 @@
  * - testgaps: Test coverage analysis (20 min interval)
  */
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
 import { cpus } from 'os';
 import { join, resolve } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
@@ -106,14 +106,15 @@ export class WorkerDaemon extends EventEmitter {
             this.headlessAvailable = await this.headlessExecutor.isAvailable();
             if (this.headlessAvailable) {
                 this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
-                this.headlessExecutor.on('execution:start', (data) => {
+                // Forward headless executor events.
+                // The executor emits 'start', 'complete', 'error' (not 'execution:*').
+                this.headlessExecutor.on('start', (data) => {
                     this.emit('headless:start', data);
                 });
-                this.headlessExecutor.on('execution:complete', (data) => {
+                this.headlessExecutor.on('complete', (data) => {
                     this.emit('headless:complete', data);
                 });
-                this.headlessExecutor.on('execution:error', (data) => {
+                this.headlessExecutor.on('error', (data) => {
                     this.emit('headless:error', data);
                 });
                 this.headlessExecutor.on('output', (data) => {
@@ -189,6 +190,12 @@ export class WorkerDaemon extends EventEmitter {
             return {};
         }
         try {
+            // Guard against OOM from an oversized config file (tampered or corrupted).
+            const configSize = statSync(configPath).size;
+            if (configSize > 1_048_576 /* 1 MB */) {
+                this.log('warn', `config.json is unusually large (${configSize} bytes) — ignoring daemon config`);
+                return {};
+            }
             const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
             // Support both flat keys at root and nested under scopes.project
             const cfg = raw?.scopes?.project ?? raw;
@@ -271,6 +278,12 @@ export class WorkerDaemon extends EventEmitter {
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
             try {
+                // Guard against OOM from an oversized state file (tampered or corrupted).
+                const stateSize = statSync(this.config.stateFile).size;
+                if (stateSize > 5_242_880 /* 5 MB */) {
+                    this.log('warn', `daemon-state.json is unusually large (${stateSize} bytes) — starting with fresh state`);
+                    return;
+                }
                 const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
                 // CRITICAL: Restore worker config (including enabled flag) from saved state
                 // This fixes #950: daemon enable command not persisting worker state
@@ -555,6 +568,17 @@ export class WorkerDaemon extends EventEmitter {
         const state = this.workers.get(workerConfig.type);
         const workerId = `${workerConfig.type}_${Date.now()}`;
         const startTime = Date.now();
+        // Track the headless executionId assigned by HeadlessWorkerExecutor so we
+        // can cancel it precisely on timeout. The executor generates its own ID
+        // (format: `${type}_${ts}_${random}`) which never matches workerId, so we
+        // capture it from the 'start' event instead.
+        let headlessExecutionId = null;
+        const onHeadlessStart = (data) => {
+            headlessExecutionId = data.executionId ?? null;
+        };
+        if (this.headlessExecutor) {
+            this.headlessExecutor.on('start', onHeadlessStart);
+        }
         // Track running worker
         this.runningWorkers.add(workerConfig.type);
         state.isRunning = true;
@@ -566,11 +590,13 @@ export class WorkerDaemon extends EventEmitter {
             // cancelAll() was too broad — it would kill concurrent healthy workers.
             const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
                 if (this.headlessExecutor) {
-                    // Try exact-ID cancel first; fall back to type-based cancel which
-                    // avoids killing unrelated concurrent workers (cancelByType).
-                    if (!this.headlessExecutor.cancel(workerId)) {
-                        this.headlessExecutor.cancelByType(workerConfig.type);
+                    // Use the exact executionId captured from the 'start' event.
+                    // Fall back to cancelByType only if we didn't capture an ID yet
+                    // (e.g. timeout fired before the executor emitted 'start').
+                    if (headlessExecutionId && this.headlessExecutor.cancel(headlessExecutionId)) {
+                        return;
                     }
+                    this.headlessExecutor.cancelByType(workerConfig.type);
                 }
             });
             const durationMs = Date.now() - startTime;
@@ -615,6 +641,10 @@ export class WorkerDaemon extends EventEmitter {
         finally {
             // Remove from running set and process queue
             this.runningWorkers.delete(workerConfig.type);
+            // Unsubscribe the executionId capture listener regardless of outcome
+            if (this.headlessExecutor) {
+                this.headlessExecutor.off('start', onHeadlessStart);
+            }
             this.processPendingWorkers();
         }
     }
@@ -752,7 +782,7 @@ export class WorkerDaemon extends EventEmitter {
             checks: {
                 envFilesProtected: !existsSync(join(this.projectRoot, '.env.local')),
                 gitIgnoreExists: existsSync(join(this.projectRoot, '.gitignore')),
-                noHardcodedSecrets: true, // Would need actual scanning
+                noHardcodedSecrets: null, // Not checked in local mode — requires AI-powered scan
             },
             riskLevel: 'low',
             recommendations: [],
@@ -779,8 +809,8 @@ export class WorkerDaemon extends EventEmitter {
             memoryUsage: process.memoryUsage(),
             uptime: process.uptime(),
             optimizations: {
-                cacheHitRate: 0.78,
-                avgResponseTime: 45,
+                cacheHitRate: null, // Not measured in local mode — requires AI-powered analysis
+                avgResponseTime: null, // Not measured in local mode — requires AI-powered analysis
             },
             note: 'Install Claude Code CLI for AI-powered optimization suggestions',
         };
@@ -1042,6 +1072,17 @@ export class WorkerDaemon extends EventEmitter {
         try {
             const logFile = join(this.config.logDir, 'daemon.log');
             appendFileSync(logFile, logMessage + '\n');
+            // Opportunistic rotation: keep the log under 10 MB. When exceeded,
+            // discard the oldest half so recent entries are always retained.
+            const MAX_LOG_BYTES = 10 * 1024 * 1024;
+            if (statSync(logFile).size > MAX_LOG_BYTES) {
+                const content = readFileSync(logFile, 'utf-8');
+                const lines = content.split('\n').filter(Boolean);
+                const trimmed = lines.slice(Math.floor(lines.length / 2)).join('\n') + '\n';
+                const tmp = `${logFile}.${process.pid}.${Date.now()}.tmp`;
+                writeFileSync(tmp, trimmed);
+                renameSync(tmp, logFile);
+            }
         }
         catch {
             // Ignore log write errors

package/packages/@monomind/cli/dist/src/services/worker-queue.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Worker Queue Service
+ * Redis-based task queue for distributed headless worker execution.
+ *
+ * ADR-020: Headless Worker Integration Architecture - Phase 4
+ * - Priority-based task scheduling
+ * - Result persistence and retrieval
+ * - Distributed locking for task assignment
+ * - Dead letter queue for failed tasks
+ * - Metrics and monitoring
+ *
+ * Key Features:
+ * - FIFO with priority levels (critical, high, normal, low)
+ * - Automatic retry with exponential backoff
+ * - Task timeout detection
+ * - Result caching with TTL
+ * - Worker heartbeat monitoring
+ */
+import { EventEmitter } from 'events';
+import type { HeadlessWorkerType, HeadlessExecutionResult, WorkerPriority } from './headless-worker-executor.js';
+/**
+ * Task status
+ */
+export type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+/**
+ * Queue task
+ */
+export interface QueueTask {
+    id: string;
+    workerType: HeadlessWorkerType;
+    priority: WorkerPriority;
+    payload: {
+        prompt?: string;
+        contextPatterns?: string[];
+        sandbox?: string;
+        model?: string;
+        timeoutMs?: number;
+    };
+    status: TaskStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    workerId?: string;
+    retryCount: number;
+    maxRetries: number;
+    result?: HeadlessExecutionResult;
+    error?: string;
+}
+/**
+ * Queue configuration
+ */
+export interface WorkerQueueConfig {
+    /** Redis connection URL */
+    redisUrl: string;
+    /** Queue name prefix */
+    queuePrefix: string;
+    /** Default task timeout in ms */
+    defaultTimeoutMs: number;
+    /** Maximum retries for failed tasks */
+    maxRetries: number;
+    /** Task result TTL in seconds */
+    resultTtlSeconds: number;
+    /** Worker heartbeat interval in ms */
+    heartbeatIntervalMs: number;
+    /** Dead letter queue enabled */
+    deadLetterEnabled: boolean;
+    /** Visibility timeout in ms (task processing lock) */
+    visibilityTimeoutMs: number;
+}
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+    pending: number;
+    processing: number;
+    completed: number;
+    failed: number;
+    deadLetter: number;
+    byPriority: Record<WorkerPriority, number>;
+    byWorkerType: Partial<Record<HeadlessWorkerType, number>>;
+    averageWaitTimeMs: number;
+    averageProcessingTimeMs: number;
+}
+/**
+ * Worker registration info
+ */
+export interface WorkerRegistration {
+    workerId: string;
+    workerTypes: HeadlessWorkerType[];
+    maxConcurrent: number;
+    currentTasks: number;
+    lastHeartbeat: Date;
+    registeredAt: Date;
+    hostname?: string;
+    containerId?: string;
+}
+/**
+ * WorkerQueue - Redis-based task queue for distributed worker execution
+ */
+export declare class WorkerQueue extends EventEmitter {
+    private config;
+    private store;
+    private workerId;
+    private heartbeatTimer?;
+    private visibilityTimer?;
+    private retryTimers;
+    private processingTasks;
+    private taskGenerations;
+    private isShuttingDown;
+    private maxConcurrent;
+    private initialized;
+    constructor(config?: Partial<WorkerQueueConfig>);
+    /**
+     * Initialize the queue (starts cleanup timers)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Requeue processing tasks that exceeded the visibility timeout (crashed workers).
+     */
+    private startVisibilityReaper;
+    /**
+     * Enqueue a new task
+     */
+    enqueue(workerType: HeadlessWorkerType, payload?: QueueTask['payload'], options?: {
+        priority?: WorkerPriority;
+        maxRetries?: number;
+        timeoutMs?: number;
+    }): Promise<string>;
+    /**
+     * Dequeue a task for processing
+     */
+    dequeue(workerTypes: HeadlessWorkerType[]): Promise<QueueTask | null>;
+    /**
+     * Complete a task with result
+     */
+    complete(taskId: string, result: HeadlessExecutionResult, leaseGen?: number): Promise<void>;
+    /**
+     * Fail a task with error
+     */
+    fail(taskId: string, error: string, retryable?: boolean, leaseGen?: number): Promise<void>;
+    /**
+     * Get task status
+     */
+    getTask(taskId: string): Promise<QueueTask | null>;
+    /**
+     * Get task result
+     */
+    getResult(taskId: string): Promise<HeadlessExecutionResult | null>;
+    /**
+     * Cancel a pending task
+     */
+    cancel(taskId: string): Promise<boolean>;
+    /**
+     * Register this instance as a worker
+     */
+    registerWorker(workerTypes: HeadlessWorkerType[], options?: {
+        maxConcurrent?: number;
+        hostname?: string;
+        containerId?: string;
+    }): Promise<string>;
+    /**
+     * Unregister this worker
+     */
+    unregisterWorker(): Promise<void>;
+    /**
+     * Get all registered workers
+     */
+    getWorkers(): Promise<WorkerRegistration[]>;
+    /**
+     * Get queue statistics
+     */
+    getStats(): Promise<QueueStats>;
+    /**
+     * Start processing tasks
+     */
+    start(workerTypes: HeadlessWorkerType[], handler: (task: QueueTask) => Promise<HeadlessExecutionResult>, options?: {
+        maxConcurrent?: number;
+    }): Promise<void>;
+    /**
+     * Process a single task
+     */
+    private processTask;
+    /**
+     * Shutdown the queue gracefully
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get queue name for worker type
+     */
+    private getQueueName;
+    /**
+     * Start heartbeat timer
+     */
+    private startHeartbeat;
+    /**
+     * Stop heartbeat timer
+     */
+    private stopHeartbeat;
+}
+export default WorkerQueue;
+//# sourceMappingURL=worker-queue.d.ts.map