@mutineerjs/mutineer 0.2.4 → 0.4.0

package/dist/runner/pool/jest/pool.js

@@ -1,309 +0,0 @@
-import { fork } from 'node:child_process';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { EventEmitter } from 'node:events';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-class JestWorker extends EventEmitter {
-    constructor(id, cwd, jestConfig, debug = false) {
-        super();
-        this.cwd = cwd;
-        this.jestConfig = jestConfig;
-        this.debug = debug;
-        this.process = null;
-        this.pendingTask = null;
-        this.ready = false;
-        this.shuttingDown = false;
-        this.id = id;
-    }
-    async start() {
-        const workerJs = path.join(__dirname, 'worker.js');
-        const workerMts = path.join(__dirname, 'worker.mjs');
-        const workerTs = path.join(__dirname, 'worker.mts');
-        const workerScript = fs.existsSync(workerJs)
-            ? workerJs
-            : fs.existsSync(workerMts)
-                ? workerMts
-                : workerTs;
-        const env = {
-            ...process.env,
-            MUTINEER_WORKER_ID: this.id,
-            MUTINEER_CWD: this.cwd,
-            ...(this.jestConfig ? { MUTINEER_JEST_CONFIG: this.jestConfig } : {}),
-            ...(this.debug ? { MUTINEER_DEBUG: '1' } : {}),
-        };
-        this.log('Starting Jest worker process');
-        this.process = fork(workerScript, [], {
-            cwd: this.cwd,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-            execArgv: ['--experimental-strip-types', '--experimental-transform-types', '--no-warnings'],
-        });
-        this.process.stderr?.on('data', (data) => {
-            if (this.debug) {
-                process.stderr.write(`[jest-worker-${this.id}] ${data}`);
-            }
-        });
-        this.process.on('message', (msg) => this.handleMessage(msg));
-        this.process.on('error', (err) => {
-            this.log(`Process error: ${err.message}`);
-            this.handleExit(1);
-        });
-        this.process.on('exit', (code) => {
-            this.log(`Process exited with code ${code}`);
-            this.handleExit(code ?? 1);
-        });
-        await new Promise((resolve, reject) => {
-            const timeoutMs = 60_000;
-            const timeout = setTimeout(() => {
-                reject(new Error(`Worker ${this.id} did not become ready in time (${timeoutMs}ms)`));
-            }, timeoutMs);
-            this.once('ready', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            this.once('error', (err) => {
-                clearTimeout(timeout);
-                reject(err);
-            });
-        });
-    }
-    handleMessage(raw) {
-        const msg = raw;
-        if (msg.type === 'ready') {
-            this.ready = true;
-            this.emit('ready');
-            return;
-        }
-        if (msg.type === 'result') {
-            if (this.pendingTask) {
-                const { resolve, timeoutHandle } = this.pendingTask;
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
-                this.pendingTask = null;
-                resolve({
-                    killed: msg.killed ?? true,
-                    durationMs: msg.durationMs ?? 0,
-                    error: msg.error,
-                });
-            }
-            return;
-        }
-        if (msg.type === 'shutdown') {
-            this.emit('shutdown');
-            return;
-        }
-    }
-    handleExit(code) {
-        this.ready = false;
-        if (this.pendingTask && !this.shuttingDown) {
-            const { reject, timeoutHandle } = this.pendingTask;
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            this.pendingTask = null;
-            reject(new Error(`Worker exited unexpectedly with code ${code}`));
-        }
-        this.emit('exit', code);
-    }
-    isReady() {
-        return this.ready && this.process !== null && !this.shuttingDown;
-    }
-    isBusy() {
-        return this.pendingTask !== null;
-    }
-    async run(mutant, tests, timeoutMs = 10_000) {
-        if (!this.isReady()) {
-            throw new Error(`Worker ${this.id} is not ready`);
-        }
-        if (this.isBusy()) {
-            throw new Error(`Worker ${this.id} is busy`);
-        }
-        return new Promise((resolve, reject) => {
-            const timeoutHandle = setTimeout(() => {
-                if (this.pendingTask) {
-                    this.pendingTask = null;
-                    this.kill();
-                    resolve({ killed: true, durationMs: timeoutMs, error: 'timeout' });
-                }
-            }, timeoutMs);
-            this.pendingTask = { resolve, reject, timeoutHandle };
-            this.process.send?.({ type: 'run', mutant, tests });
-        });
-    }
-    async shutdown() {
-        if (!this.process || this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                this.kill();
-                resolve();
-            }, 5000);
-            this.once('shutdown', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            this.process.send?.({ type: 'shutdown' });
-        });
-    }
-    kill() {
-        if (this.process) {
-            try {
-                this.process.kill('SIGKILL');
-            }
-            catch {
-                // ignore
-            }
-            this.process = null;
-        }
-        this.ready = false;
-    }
-    log(msg) {
-        if (this.debug) {
-            console.error(`[JestWorker-${this.id}] ${msg}`);
-        }
-    }
-}
-export class JestPool {
-    constructor(options) {
-        this.workers = [];
-        this.availableWorkers = [];
-        this.waitingTasks = [];
-        this.initialized = false;
-        this.shuttingDown = false;
-        this.options = {
-            cwd: options.cwd,
-            concurrency: options.concurrency,
-            jestConfig: options.jestConfig,
-            timeoutMs: options.timeoutMs ?? 10_000,
-            debug: options.debug ?? false,
-            createWorker: options.createWorker,
-        };
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        const startPromises = [];
-        for (let i = 0; i < this.options.concurrency; i++) {
-            const worker = this.options.createWorker?.(`w${i}`, {
-                cwd: this.options.cwd,
-                jestConfig: this.options.jestConfig,
-                debug: this.options.debug,
-            }) ??
-                new JestWorker(`w${i}`, this.options.cwd, this.options.jestConfig, this.options.debug);
-            worker.on('exit', () => {
-                if (!this.shuttingDown) {
-                    this.handleWorkerExit(worker);
-                }
-            });
-            this.workers.push(worker);
-            startPromises.push(worker.start().then(() => {
-                this.availableWorkers.push(worker);
-            }));
-        }
-        await Promise.all(startPromises);
-        this.initialized = true;
-    }
-    handleWorkerExit(worker) {
-        const availIdx = this.availableWorkers.indexOf(worker);
-        if (availIdx >= 0) {
-            this.availableWorkers.splice(availIdx, 1);
-        }
-        const newWorker = this.options.createWorker?.(worker.id, {
-            cwd: this.options.cwd,
-            jestConfig: this.options.jestConfig,
-            debug: this.options.debug,
-        }) ??
-            new JestWorker(worker.id, this.options.cwd, this.options.jestConfig, this.options.debug);
-        const idx = this.workers.indexOf(worker);
-        if (idx >= 0) {
-            this.workers[idx] = newWorker;
-        }
-        newWorker.on('exit', () => {
-            if (!this.shuttingDown) {
-                this.handleWorkerExit(newWorker);
-            }
-        });
-        newWorker.start()
-            .then(() => {
-            this.releaseWorker(newWorker);
-        })
-            .catch((err) => {
-            this.log(`Failed to restart worker ${newWorker.id}: ${err}`);
-        });
-    }
-    async acquireWorker() {
-        const worker = this.availableWorkers.shift();
-        if (worker) {
-            return worker;
-        }
-        return new Promise((resolve) => {
-            this.waitingTasks.push(resolve);
-        });
-    }
-    releaseWorker(worker) {
-        const waiting = this.waitingTasks.shift();
-        if (waiting) {
-            waiting(worker);
-            return;
-        }
-        if (worker.isReady()) {
-            this.availableWorkers.push(worker);
-        }
-    }
-    async run(mutant, tests) {
-        if (!this.initialized) {
-            throw new Error('Pool not initialized. Call init() first.');
-        }
-        if (this.shuttingDown) {
-            throw new Error('Pool is shutting down');
-        }
-        const worker = await this.acquireWorker();
-        try {
-            const result = await worker.run(mutant, tests, this.options.timeoutMs);
-            if (this.options.debug) {
-                console.error(`[JestPool] worker ${worker.id} returned killed=${result.killed} error=${result.error ?? 'none'} duration=${result.durationMs}`);
-            }
-            return result;
-        }
-        finally {
-            this.releaseWorker(worker);
-        }
-    }
-    async shutdown() {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        await Promise.all(this.workers.map((w) => w.shutdown()));
-        this.workers = [];
-        this.availableWorkers = [];
-        this.initialized = false;
-    }
-    log(msg) {
-        if (this.options.debug) {
-            console.error(`[JestPool] ${msg}`);
-        }
-    }
-}
-export async function runWithJestPool(pool, mutant, tests) {
-    try {
-        const result = await pool.run(mutant, [...tests]);
-        if (result.error === 'timeout') {
-            return { status: 'timeout', durationMs: result.durationMs, error: result.error };
-        }
-        if (result.error && !result.killed) {
-            return { status: 'error', durationMs: result.durationMs, error: result.error };
-        }
-        return {
-            status: result.killed ? 'killed' : 'escaped',
-            durationMs: result.durationMs,
-        };
-    }
-    catch (err) {
-        return {
-            status: 'error',
-            durationMs: 0,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}

package/dist/runner/pool/jest/worker.d.mts

@@ -1 +0,0 @@
-export {};

package/dist/runner/pool/jest/worker.mjs

@@ -1,60 +0,0 @@
-import { createJestWorkerRuntime } from '../../adapters/jest/worker-runtime.js';
-globalThis.__mutineer_redirect__ = { from: null, to: null };
-function log(msg) {
-    if (process.env.MUTINEER_DEBUG !== '1')
-        return;
-    console.error(`[jest-worker] ${msg}`);
-}
-async function main() {
-    const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
-    const cwd = process.env.MUTINEER_CWD ?? process.cwd();
-    const jestConfigPath = process.env.MUTINEER_JEST_CONFIG;
-    const debug = process.env.MUTINEER_DEBUG === '1';
-    log(`Starting worker ${workerId} in ${cwd}`);
-    const runtime = createJestWorkerRuntime({
-        workerId,
-        cwd,
-        jestConfigPath,
-        debug,
-    });
-    try {
-        await runtime.init();
-    }
-    catch (err) {
-        console.error('[jest-worker] Failed to initialize:', err);
-        process.exit(1);
-    }
-    process.send?.({ type: 'ready', workerId });
-    process.on('message', async (raw) => {
-        if (raw.type === 'shutdown') {
-            log('Shutting down');
-            await runtime.shutdown();
-            process.send?.({ type: 'shutdown', ok: true });
-            process.exit(0);
-        }
-        if (raw.type === 'run') {
-            try {
-                const { mutant, tests } = raw;
-                const result = await runtime.run(mutant, tests);
-                process.send?.({
-                    type: 'result',
-                    killed: result.killed,
-                    durationMs: result.durationMs,
-                    error: result.error,
-                });
-            }
-            catch (err) {
-                process.send?.({
-                    type: 'result',
-                    killed: true,
-                    durationMs: 0,
-                    error: String(err),
-                });
-            }
-        }
-    });
-}
-main().catch((err) => {
-    console.error('[jest-worker] Fatal error:', err);
-    process.exit(1);
-});

package/dist/runner/pool/jest-pool.d.ts

@@ -1,52 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';
-declare class JestWorker extends EventEmitter {
-    private readonly cwd;
-    private readonly jestConfig?;
-    private readonly debug;
-    readonly id: string;
-    private process;
-    private pendingTask;
-    private ready;
-    private shuttingDown;
-    constructor(id: string, cwd: string, jestConfig?: string | undefined, debug?: boolean);
-    start(): Promise<void>;
-    private handleMessage;
-    private handleExit;
-    isReady(): boolean;
-    isBusy(): boolean;
-    run(mutant: MutantPayload, tests: string[], timeoutMs?: number): Promise<MutantRunSummary>;
-    shutdown(): Promise<void>;
-    kill(): void;
-    private log;
-}
-export interface JestPoolOptions {
-    cwd: string;
-    concurrency: number;
-    jestConfig?: string;
-    timeoutMs?: number;
-    debug?: boolean;
-    createWorker?: (id: string, opts: {
-        cwd: string;
-        jestConfig?: string;
-        debug: boolean;
-    }) => JestWorker;
-}
-export declare class JestPool {
-    private workers;
-    private availableWorkers;
-    private waitingTasks;
-    private readonly options;
-    private initialized;
-    private shuttingDown;
-    constructor(options: JestPoolOptions);
-    init(): Promise<void>;
-    private handleWorkerExit;
-    private acquireWorker;
-    private releaseWorker;
-    run(mutant: MutantPayload, tests: string[]): Promise<MutantRunSummary>;
-    shutdown(): Promise<void>;
-    private log;
-}
-export declare function runWithJestPool(pool: JestPool, mutant: MutantPayload, tests: readonly string[]): Promise<MutantRunResult>;
-export type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../types/mutant.js';