pidnap 0.0.0-dev.0

package/dist/logger-crc5neL8.mjs

@@ -0,0 +1,966 @@
+import { basename, join, resolve } from "node:path";
+import * as v from "valibot";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+import { Cron } from "croner";
+import { appendFileSync, existsSync, globSync, readFileSync, watch } from "node:fs";
+import { parse } from "dotenv";
+import { readFile } from "node:fs/promises";
+import { format } from "node:util";
+
+//#region src/lazy-process.ts
+const ProcessDefinitionSchema = v.object({
+	command: v.string(),
+	args: v.optional(v.array(v.string())),
+	cwd: v.optional(v.string()),
+	env: v.optional(v.record(v.string(), v.string()))
+});
+const ProcessStateSchema = v.picklist([
+	"idle",
+	"starting",
+	"running",
+	"stopping",
+	"stopped",
+	"error"
+]);
+/**
+* Kill a process. Tries to kill the process group first (if available),
+* then falls back to killing just the process.
+*/
+function killProcess(child, signal) {
+	try {
+		return child.kill(signal);
+	} catch {
+		return false;
+	}
+}
+var LazyProcess = class {
+	name;
+	definition;
+	logger;
+	childProcess = null;
+	_state = "idle";
+	processExit = Promise.withResolvers();
+	exitCode = null;
+	constructor(name, definition, logger) {
+		this.name = name;
+		this.definition = definition;
+		this.logger = logger;
+	}
+	get state() {
+		return this._state;
+	}
+	start() {
+		if (this._state === "running" || this._state === "starting") throw new Error(`Process "${this.name}" is already ${this._state}`);
+		if (this._state === "stopping") throw new Error(`Process "${this.name}" is currently stopping`);
+		this._state = "starting";
+		this.logger.info(`Starting process: ${this.definition.command}`);
+		try {
+			const env = this.definition.env ? {
+				...process.env,
+				...this.definition.env
+			} : process.env;
+			this.childProcess = spawn(this.definition.command, this.definition.args ?? [], {
+				cwd: this.definition.cwd,
+				env,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			this._state = "running";
+			const combined = new PassThrough();
+			let streamCount = 0;
+			if (this.childProcess.stdout) {
+				streamCount++;
+				this.childProcess.stdout.pipe(combined, { end: false });
+				this.childProcess.stdout.on("end", () => {
+					if (--streamCount === 0) combined.end();
+				});
+			}
+			if (this.childProcess.stderr) {
+				streamCount++;
+				this.childProcess.stderr.pipe(combined, { end: false });
+				this.childProcess.stderr.on("end", () => {
+					if (--streamCount === 0) combined.end();
+				});
+			}
+			readline.createInterface({ input: combined }).on("line", (line) => {
+				this.logger.info(line);
+			});
+			this.childProcess.on("exit", (code, signal) => {
+				this.exitCode = code;
+				if (this._state === "running") if (code === 0) {
+					this._state = "stopped";
+					this.logger.info(`Process exited with code ${code}`);
+				} else if (signal) {
+					this._state = "stopped";
+					this.logger.info(`Process killed with signal ${signal}`);
+				} else {
+					this._state = "error";
+					this.logger.error(`Process exited with code ${code}`);
+				}
+				this.processExit.resolve();
+			});
+			this.childProcess.on("error", (err) => {
+				if (this._state !== "stopping" && this._state !== "stopped") {
+					this._state = "error";
+					this.logger.error(`Process error:`, err);
+				}
+				this.processExit.resolve();
+			});
+		} catch (err) {
+			this._state = "error";
+			this.logger.error(`Failed to start process:`, err);
+			throw err;
+		}
+	}
+	async stop(timeout) {
+		if (this._state === "idle" || this._state === "stopped" || this._state === "error") return;
+		if (this._state === "stopping") {
+			await this.processExit.promise;
+			return;
+		}
+		if (!this.childProcess) {
+			this._state = "stopped";
+			return;
+		}
+		this._state = "stopping";
+		this.logger.info(`Stopping process with SIGTERM`);
+		killProcess(this.childProcess, "SIGTERM");
+		const timeoutMs = timeout ?? 5e3;
+		const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), timeoutMs));
+		if (await Promise.race([this.processExit.promise.then(() => "exited"), timeoutPromise]) === "timeout" && this.childProcess) {
+			this.logger.warn(`Process did not exit within ${timeoutMs}ms, sending SIGKILL`);
+			killProcess(this.childProcess, "SIGKILL");
+			const killTimeout = new Promise((resolve) => setTimeout(resolve, 1e3));
+			await Promise.race([this.processExit.promise, killTimeout]);
+		}
+		this._state = "stopped";
+		this.cleanup();
+		this.logger.info(`Process stopped`);
+	}
+	async reset() {
+		if (this.childProcess) {
+			killProcess(this.childProcess, "SIGKILL");
+			await this.processExit.promise;
+			this.cleanup();
+		}
+		this._state = "idle";
+		this.processExit = Promise.withResolvers();
+		this.logger.info(`Process reset to idle`);
+	}
+	updateDefinition(definition) {
+		this.definition = definition;
+	}
+	async waitForExit() {
+		if (!this.childProcess) return this._state;
+		await this.processExit.promise;
+		return this._state;
+	}
+	cleanup() {
+		if (this.childProcess) {
+			this.childProcess.stdout?.removeAllListeners();
+			this.childProcess.stderr?.removeAllListeners();
+			this.childProcess.removeAllListeners();
+			this.childProcess = null;
+		}
+		this.exitCode = null;
+	}
+};
+
+//#endregion
+//#region src/restarting-process.ts
+const RestartPolicySchema = v.picklist([
+	"always",
+	"on-failure",
+	"never",
+	"unless-stopped",
+	"on-success"
+]);
+const BackoffStrategySchema = v.union([v.object({
+	type: v.literal("fixed"),
+	delayMs: v.number()
+}), v.object({
+	type: v.literal("exponential"),
+	initialDelayMs: v.number(),
+	maxDelayMs: v.number(),
+	multiplier: v.optional(v.number())
+})]);
+const CrashLoopConfigSchema = v.object({
+	maxRestarts: v.number(),
+	windowMs: v.number(),
+	backoffMs: v.number()
+});
+const RestartingProcessOptionsSchema = v.object({
+	restartPolicy: RestartPolicySchema,
+	backoff: v.optional(BackoffStrategySchema),
+	crashLoop: v.optional(CrashLoopConfigSchema),
+	minUptimeMs: v.optional(v.number()),
+	maxTotalRestarts: v.optional(v.number())
+});
+const RestartingProcessStateSchema = v.picklist([
+	"idle",
+	"running",
+	"restarting",
+	"stopping",
+	"stopped",
+	"crash-loop-backoff",
+	"max-restarts-reached"
+]);
+const DEFAULT_BACKOFF = {
+	type: "fixed",
+	delayMs: 1e3
+};
+const DEFAULT_CRASH_LOOP = {
+	maxRestarts: 5,
+	windowMs: 6e4,
+	backoffMs: 6e4
+};
+var RestartingProcess = class {
+	name;
+	lazyProcess;
+	definition;
+	options;
+	logger;
+	_state = "idle";
+	_restartCount = 0;
+	restartTimestamps = [];
+	consecutiveFailures = 0;
+	lastStartTime = null;
+	stopRequested = false;
+	pendingDelayTimeout = null;
+	constructor(name, definition, options, logger) {
+		this.name = name;
+		this.definition = definition;
+		this.logger = logger;
+		this.options = {
+			restartPolicy: options.restartPolicy,
+			backoff: options.backoff ?? DEFAULT_BACKOFF,
+			crashLoop: options.crashLoop ?? DEFAULT_CRASH_LOOP,
+			minUptimeMs: options.minUptimeMs ?? 0,
+			maxTotalRestarts: options.maxTotalRestarts
+		};
+		this.lazyProcess = new LazyProcess(name, definition, logger);
+	}
+	get state() {
+		return this._state;
+	}
+	get restarts() {
+		return this._restartCount;
+	}
+	start() {
+		if (this._state === "running" || this._state === "restarting") throw new Error(`Process "${this.name}" is already ${this._state}`);
+		if (this._state === "stopping") throw new Error(`Process "${this.name}" is currently stopping`);
+		if (this._state === "stopped" || this._state === "idle" || this._state === "max-restarts-reached") this.resetCounters();
+		this.stopRequested = false;
+		this.startProcess();
+	}
+	async stop(timeout) {
+		this.stopRequested = true;
+		if (this.pendingDelayTimeout) {
+			clearTimeout(this.pendingDelayTimeout);
+			this.pendingDelayTimeout = null;
+		}
+		if (this._state === "idle" || this._state === "stopped" || this._state === "max-restarts-reached") {
+			this._state = "stopped";
+			return;
+		}
+		this._state = "stopping";
+		await this.lazyProcess.stop(timeout);
+		this._state = "stopped";
+		this.logger.info(`RestartingProcess stopped`);
+	}
+	async restart(force = false) {
+		if (this._state === "stopped" || this._state === "idle" || this._state === "max-restarts-reached") {
+			this.resetCounters();
+			this.stopRequested = false;
+			this.startProcess();
+			return;
+		}
+		await this.stop();
+		this.stopRequested = false;
+		if (force) this.startProcess();
+		else {
+			const delay = this.calculateDelay();
+			if (delay > 0) {
+				this._state = "restarting";
+				this.logger.info(`Restarting in ${delay}ms`);
+				await this.delay(delay);
+				if (this.stopRequested) return;
+			}
+			this.startProcess();
+		}
+	}
+	/**
+	* Update process definition and optionally restart with new config
+	*/
+	async reload(newDefinition, restartImmediately = true) {
+		this.logger.info(`Reloading process with new definition`);
+		this.definition = newDefinition;
+		this.lazyProcess.updateDefinition(newDefinition);
+		if (restartImmediately) await this.restart(true);
+	}
+	/**
+	* Update restart options
+	*/
+	updateOptions(newOptions) {
+		this.logger.info(`Updating restart options`);
+		this.options = {
+			...this.options,
+			restartPolicy: newOptions.restartPolicy ?? this.options.restartPolicy,
+			backoff: newOptions.backoff ?? this.options.backoff,
+			crashLoop: newOptions.crashLoop ?? this.options.crashLoop,
+			minUptimeMs: newOptions.minUptimeMs ?? this.options.minUptimeMs,
+			maxTotalRestarts: newOptions.maxTotalRestarts ?? this.options.maxTotalRestarts
+		};
+	}
+	resetCounters() {
+		this._restartCount = 0;
+		this.consecutiveFailures = 0;
+		this.restartTimestamps = [];
+	}
+	startProcess() {
+		this.lastStartTime = Date.now();
+		this._state = "running";
+		this.lazyProcess.reset().then(() => {
+			if (this.stopRequested) return;
+			this.lazyProcess.start();
+			return this.lazyProcess.waitForExit();
+		}).then((exitState) => {
+			if (!exitState) return;
+			if (this.stopRequested && exitState === "error") {
+				this._state = "stopped";
+				return;
+			}
+			if (exitState === "stopped" || exitState === "error") this.handleProcessExit(exitState);
+		}).catch((err) => {
+			if (this.stopRequested) return;
+			this._state = "stopped";
+			this.logger.error(`Failed to start process:`, err);
+		});
+	}
+	handleProcessExit(exitState) {
+		if (this.stopRequested) {
+			this._state = "stopped";
+			return;
+		}
+		const wasHealthy = (this.lastStartTime ? Date.now() - this.lastStartTime : 0) >= this.options.minUptimeMs;
+		const exitedWithError = exitState === "error";
+		if (wasHealthy) this.consecutiveFailures = 0;
+		else this.consecutiveFailures++;
+		if (!this.shouldRestart(exitedWithError)) {
+			this._state = "stopped";
+			this.logger.info(`Process exited, policy "${this.options.restartPolicy}" does not allow restart`);
+			return;
+		}
+		if (this.options.maxTotalRestarts !== void 0 && this._restartCount >= this.options.maxTotalRestarts) {
+			this._state = "max-restarts-reached";
+			this.logger.warn(`Max total restarts (${this.options.maxTotalRestarts}) reached`);
+			return;
+		}
+		const now = Date.now();
+		this.restartTimestamps.push(now);
+		if (this.isInCrashLoop()) {
+			this._state = "crash-loop-backoff";
+			this.logger.warn(`Crash loop detected (${this.options.crashLoop.maxRestarts} restarts in ${this.options.crashLoop.windowMs}ms), backing off for ${this.options.crashLoop.backoffMs}ms`);
+			this.scheduleCrashLoopRecovery();
+			return;
+		}
+		this._restartCount++;
+		this.scheduleRestart();
+	}
+	shouldRestart(exitedWithError) {
+		switch (this.options.restartPolicy) {
+			case "always": return true;
+			case "never": return false;
+			case "on-failure": return exitedWithError;
+			case "on-success": return !exitedWithError;
+			case "unless-stopped": return !this.stopRequested;
+			default: return false;
+		}
+	}
+	isInCrashLoop() {
+		const { maxRestarts, windowMs } = this.options.crashLoop;
+		const cutoff = Date.now() - windowMs;
+		this.restartTimestamps = this.restartTimestamps.filter((ts) => ts > cutoff);
+		return this.restartTimestamps.length >= maxRestarts;
+	}
+	calculateDelay() {
+		const { backoff } = this.options;
+		if (backoff.type === "fixed") return backoff.delayMs;
+		const multiplier = backoff.multiplier ?? 2;
+		const delay = backoff.initialDelayMs * Math.pow(multiplier, this.consecutiveFailures);
+		return Math.min(delay, backoff.maxDelayMs);
+	}
+	scheduleRestart() {
+		this._state = "restarting";
+		const delay = this.calculateDelay();
+		this.logger.info(`Restarting in ${delay}ms (restart #${this._restartCount})`);
+		this.pendingDelayTimeout = setTimeout(() => {
+			this.pendingDelayTimeout = null;
+			if (this.stopRequested) {
+				this._state = "stopped";
+				return;
+			}
+			this.startProcess();
+		}, delay);
+	}
+	scheduleCrashLoopRecovery() {
+		const { backoffMs } = this.options.crashLoop;
+		this.pendingDelayTimeout = setTimeout(() => {
+			this.pendingDelayTimeout = null;
+			if (this.stopRequested) {
+				this._state = "stopped";
+				return;
+			}
+			this.restartTimestamps = [];
+			this._restartCount++;
+			this.logger.info(`Crash loop backoff complete, restarting (restart #${this._restartCount})`);
+			this.startProcess();
+		}, backoffMs);
+	}
+	delay(ms) {
+		return new Promise((resolve) => {
+			this.pendingDelayTimeout = setTimeout(() => {
+				this.pendingDelayTimeout = null;
+				resolve();
+			}, ms);
+		});
+	}
+};
+
+//#endregion
+//#region src/cron-process.ts
+const RetryConfigSchema = v.object({
+	maxRetries: v.number(),
+	delayMs: v.optional(v.number())
+});
+const CronProcessOptionsSchema = v.object({
+	schedule: v.string(),
+	retry: v.optional(RetryConfigSchema),
+	runOnStart: v.optional(v.boolean())
+});
+const CronProcessStateSchema = v.picklist([
+	"idle",
+	"scheduled",
+	"running",
+	"retrying",
+	"queued",
+	"stopping",
+	"stopped"
+]);
+const DEFAULT_RETRY_DELAY = 1e3;
+var CronProcess = class {
+	name;
+	lazyProcess;
+	options;
+	logger;
+	cronJob = null;
+	_state = "idle";
+	_runCount = 0;
+	_failCount = 0;
+	currentRetryAttempt = 0;
+	queuedRun = false;
+	stopRequested = false;
+	retryTimeout = null;
+	constructor(name, definition, options, logger) {
+		this.name = name;
+		this.options = options;
+		this.logger = logger;
+		this.lazyProcess = new LazyProcess(name, definition, logger);
+	}
+	get state() {
+		return this._state;
+	}
+	get runCount() {
+		return this._runCount;
+	}
+	get failCount() {
+		return this._failCount;
+	}
+	get nextRun() {
+		if (!this.cronJob) return null;
+		return this.cronJob.nextRun() ?? null;
+	}
+	start() {
+		if (this._state === "scheduled" || this._state === "running" || this._state === "queued") throw new Error(`CronProcess "${this.name}" is already ${this._state}`);
+		if (this._state === "stopping") throw new Error(`CronProcess "${this.name}" is currently stopping`);
+		this.stopRequested = false;
+		this.logger.info(`Starting cron schedule: ${this.options.schedule}`);
+		this.cronJob = new Cron(this.options.schedule, { timezone: "UTC" }, () => {
+			this.onCronTick();
+		});
+		this._state = "scheduled";
+		if (this.options.runOnStart) this.executeJob();
+	}
+	async stop(timeout) {
+		this.stopRequested = true;
+		if (this.cronJob) {
+			this.cronJob.stop();
+			this.cronJob = null;
+		}
+		if (this.retryTimeout) {
+			clearTimeout(this.retryTimeout);
+			this.retryTimeout = null;
+		}
+		if (this._state === "idle" || this._state === "stopped") {
+			this._state = "stopped";
+			return;
+		}
+		if (this._state === "running" || this._state === "retrying" || this._state === "queued") {
+			this._state = "stopping";
+			await this.lazyProcess.stop(timeout);
+		}
+		this._state = "stopped";
+		this.queuedRun = false;
+		this.logger.info(`CronProcess stopped`);
+	}
+	async trigger() {
+		if (this.stopRequested) throw new Error(`CronProcess "${this.name}" is stopped`);
+		if (this._state === "queued") return;
+		if (this._state === "running" || this._state === "retrying") {
+			this.queuedRun = true;
+			this._state = "queued";
+			this.logger.info(`Run queued (current job still running)`);
+			return;
+		}
+		await this.executeJob();
+	}
+	onCronTick() {
+		if (this.stopRequested) return;
+		if (this._state === "running" || this._state === "retrying" || this._state === "queued") {
+			this.queuedRun = true;
+			if (this._state !== "queued") this._state = "queued";
+			this.logger.info(`Cron tick: run queued (current job still running)`);
+			return;
+		}
+		this.executeJob();
+	}
+	async executeJob() {
+		if (this.stopRequested) return;
+		this._state = "running";
+		this.currentRetryAttempt = 0;
+		this.logger.info(`Executing job`);
+		await this.runJobWithRetry();
+	}
+	async runJobWithRetry() {
+		if (this.stopRequested) return;
+		await this.lazyProcess.reset();
+		this.lazyProcess.start();
+		const exitState = await this.lazyProcess.waitForExit();
+		if (this.stopRequested && exitState === "error") {
+			this._state = "stopped";
+			return;
+		}
+		this.handleJobComplete(exitState === "error");
+	}
+	handleJobComplete(failed) {
+		if (this.stopRequested) {
+			this._state = "stopped";
+			return;
+		}
+		if (failed) {
+			const maxRetries = this.options.retry?.maxRetries ?? 0;
+			if (this.currentRetryAttempt < maxRetries) {
+				this.currentRetryAttempt++;
+				this._state = "retrying";
+				const delayMs = this.options.retry?.delayMs ?? DEFAULT_RETRY_DELAY;
+				this.logger.warn(`Job failed, retrying in ${delayMs}ms (attempt ${this.currentRetryAttempt}/${maxRetries})`);
+				this.retryTimeout = setTimeout(() => {
+					this.retryTimeout = null;
+					if (this.stopRequested) {
+						this._state = "stopped";
+						return;
+					}
+					this.runJobWithRetry();
+				}, delayMs);
+				return;
+			}
+			this._failCount++;
+			this.logger.error(`Job failed after ${this.currentRetryAttempt} retries`);
+		} else {
+			this._runCount++;
+			this.logger.info(`Job completed successfully`);
+		}
+		if (this.queuedRun) {
+			this.queuedRun = false;
+			this.logger.info(`Starting queued run`);
+			this.executeJob();
+			return;
+		}
+		if (this.cronJob) this._state = "scheduled";
+		else this._state = "stopped";
+	}
+};
+
+//#endregion
+//#region src/task-list.ts
+const TaskStateSchema = v.picklist([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"skipped"
+]);
+const NamedProcessDefinitionSchema = v.object({
+	name: v.string(),
+	process: ProcessDefinitionSchema
+});
+var TaskList = class {
+	name;
+	_tasks = [];
+	_state = "idle";
+	logger;
+	logFileResolver;
+	taskIdCounter = 0;
+	runningProcesses = [];
+	stopRequested = false;
+	runLoopPromise = null;
+	constructor(name, logger, initialTasks, logFileResolver) {
+		this.name = name;
+		this.logger = logger;
+		this.logFileResolver = logFileResolver;
+		if (initialTasks) for (const task of initialTasks) this.addTask(task);
+	}
+	get state() {
+		return this._state;
+	}
+	get tasks() {
+		return this._tasks;
+	}
+	removeTaskByTarget(target) {
+		const index = typeof target === "number" ? target : this._tasks.findIndex((t) => t.id === target);
+		if (index < 0 || index >= this._tasks.length) throw new Error(`Task not found: ${target}`);
+		const task = this._tasks[index];
+		if (task.state === "running") throw new Error(`Cannot remove running task: ${task.id}`);
+		this._tasks.splice(index, 1);
+		this.logger.info(`Task "${task.id}" removed`);
+		return task;
+	}
+	/**
+	* Add a single process or parallel processes as a new task
+	* @returns The unique task ID
+	*/
+	addTask(task) {
+		const id = `task-${++this.taskIdCounter}`;
+		const processes = Array.isArray(task) ? task : [task];
+		const entry = {
+			id,
+			processes,
+			state: "pending"
+		};
+		this._tasks.push(entry);
+		this.logger.info(`Task "${id}" added with ${processes.length} process(es)`);
+		return id;
+	}
+	/**
+	* Begin executing pending tasks
+	*/
+	start() {
+		if (this._state === "running") throw new Error(`TaskList "${this.name}" is already running`);
+		this.stopRequested = false;
+		this._state = "running";
+		this.logger.info(`TaskList started`);
+		this.runLoopPromise = this.runLoop();
+	}
+	/**
+	* Wait until the TaskList becomes idle (all pending tasks completed)
+	*/
+	async waitUntilIdle() {
+		if (this._state === "idle" || this._state === "stopped") return;
+		if (this.runLoopPromise) await this.runLoopPromise;
+	}
+	/**
+	* Stop execution and mark remaining tasks as skipped
+	*/
+	async stop(timeout) {
+		if (this._state === "idle" || this._state === "stopped") {
+			this._state = "stopped";
+			return;
+		}
+		this.stopRequested = true;
+		this.logger.info(`Stopping TaskList...`);
+		const stopPromises = this.runningProcesses.map((p) => p.stop(timeout));
+		await Promise.all(stopPromises);
+		this.runningProcesses = [];
+		for (const task of this._tasks) if (task.state === "pending") task.state = "skipped";
+		if (this.runLoopPromise) {
+			await this.runLoopPromise;
+			this.runLoopPromise = null;
+		}
+		this._state = "stopped";
+		this.logger.info(`TaskList stopped`);
+	}
+	async runLoop() {
+		while (this._state === "running" && !this.stopRequested) {
+			const nextTask = this._tasks.find((t) => t.state === "pending");
+			if (!nextTask) {
+				this._state = "idle";
+				this.logger.info(`All tasks completed, TaskList is idle`);
+				break;
+			}
+			await this.executeTask(nextTask);
+		}
+	}
+	async executeTask(task) {
+		if (this.stopRequested) {
+			task.state = "skipped";
+			return;
+		}
+		task.state = "running";
+		const taskNames = task.processes.map((p) => p.name).join(", ");
+		this.logger.info(`Executing task "${task.id}": [${taskNames}]`);
+		const lazyProcesses = task.processes.map((p) => {
+			const logFile = this.logFileResolver?.(p.name);
+			const childLogger = logFile ? this.logger.child(p.name, { logFile }) : this.logger.child(p.name);
+			return new LazyProcess(p.name, p.process, childLogger);
+		});
+		this.runningProcesses = lazyProcesses;
+		try {
+			for (const lp of lazyProcesses) lp.start();
+			const anyFailed = (await Promise.all(lazyProcesses.map((lp) => this.waitForProcess(lp)))).some((r) => r === "error");
+			if (this.stopRequested) task.state = "skipped";
+			else if (anyFailed) {
+				task.state = "failed";
+				this.logger.warn(`Task "${task.id}" failed`);
+			} else {
+				task.state = "completed";
+				this.logger.info(`Task "${task.id}" completed`);
+			}
+		} catch (err) {
+			task.state = "failed";
+			this.logger.error(`Task "${task.id}" error:`, err);
+		} finally {
+			this.runningProcesses = [];
+		}
+	}
+	async waitForProcess(lp) {
+		return await lp.waitForExit() === "error" ? "error" : "stopped";
+	}
+};
+
+//#endregion
+//#region src/env-manager.ts
+var EnvManager = class {
+	env = /* @__PURE__ */ new Map();
+	cwd;
+	watchEnabled;
+	watchers = /* @__PURE__ */ new Map();
+	fileToKeys = /* @__PURE__ */ new Map();
+	changeCallbacks = /* @__PURE__ */ new Set();
+	reloadDebounceTimers = /* @__PURE__ */ new Map();
+	constructor(config = {}) {
+		this.cwd = config.cwd ?? process.cwd();
+		this.watchEnabled = config.watch ?? false;
+		this.loadEnvFilesFromCwd();
+		if (config.files) for (const [key, filePath] of Object.entries(config.files)) this.loadEnvFile(key, filePath);
+	}
+	registerFile(key, filePath) {
+		this.loadEnvFile(key, filePath);
+	}
+	getEnvForKey(key) {
+		return this.env.get(key) ?? {};
+	}
+	/**
+	* Load .env and .env.* files from the cwd
+	*/
+	loadEnvFilesFromCwd() {
+		const dotEnvPath = resolve(this.cwd, ".env");
+		if (existsSync(dotEnvPath)) this.loadEnvFile("global", dotEnvPath);
+		try {
+			const envFiles = globSync(join(this.cwd, ".env.*"));
+			for (const filePath of envFiles) {
+				const match = basename(filePath).match(/^\.env\.(.+)$/);
+				if (match) {
+					const suffix = match[1];
+					this.loadEnvFile(suffix, filePath);
+				}
+			}
+		} catch (err) {
+			console.warn("Failed to scan env files:", err);
+		}
+	}
+	/**
+	* Load a single env file and store it in the map
+	*/
+	loadEnvFile(key, filePath) {
+		const absolutePath = resolve(this.cwd, filePath);
+		if (!existsSync(absolutePath)) return;
+		try {
+			const parsed = parse(readFileSync(absolutePath, "utf-8"));
+			this.env.set(key, parsed);
+			if (!this.fileToKeys.has(absolutePath)) this.fileToKeys.set(absolutePath, /* @__PURE__ */ new Set());
+			this.fileToKeys.get(absolutePath).add(key);
+			if (this.watchEnabled && !this.watchers.has(absolutePath)) this.watchFile(absolutePath);
+		} catch (err) {
+			console.warn(`Failed to load env file: ${absolutePath}`, err);
+		}
+	}
+	/**
+	* Watch a file for changes
+	*/
+	watchFile(absolutePath) {
+		try {
+			const watcher = watch(absolutePath, (eventType) => {
+				if (eventType === "change") this.handleFileChange(absolutePath);
+			});
+			this.watchers.set(absolutePath, watcher);
+		} catch (err) {
+			console.warn(`Failed to watch env file: ${absolutePath}`, err);
+		}
+	}
+	/**
+	* Handle file change with debouncing
+	*/
+	handleFileChange(absolutePath) {
+		const existingTimer = this.reloadDebounceTimers.get(absolutePath);
+		if (existingTimer) clearTimeout(existingTimer);
+		const timer = setTimeout(() => {
+			this.reloadFile(absolutePath);
+			this.reloadDebounceTimers.delete(absolutePath);
+		}, 100);
+		this.reloadDebounceTimers.set(absolutePath, timer);
+	}
+	/**
+	* Reload a file and notify callbacks
+	*/
+	reloadFile(absolutePath) {
+		const keys = this.fileToKeys.get(absolutePath);
+		if (!keys) return;
+		readFile(absolutePath, "utf-8").then((content) => parse(content)).then((parsed) => {
+			const changedKeys = [];
+			for (const key of keys) {
+				this.env.set(key, parsed);
+				changedKeys.push(key);
+			}
+			if (changedKeys.length > 0) for (const callback of this.changeCallbacks) callback(changedKeys);
+		}).catch((err) => {
+			console.warn(`Failed to reload env file: ${absolutePath}`, err);
+		});
+	}
+	/**
+	* Register a callback to be called when env files change
+	* Returns a function to unregister the callback
+	*/
+	onChange(callback) {
+		this.changeCallbacks.add(callback);
+		return () => {
+			this.changeCallbacks.delete(callback);
+		};
+	}
+	/**
+	* Stop watching all files and cleanup
+	*/
+	dispose() {
+		for (const timer of this.reloadDebounceTimers.values()) clearTimeout(timer);
+		this.reloadDebounceTimers.clear();
+		for (const watcher of this.watchers.values()) watcher.close();
+		this.watchers.clear();
+		this.changeCallbacks.clear();
+	}
+	/**
+	* Get environment variables for a specific process
+	* Merges global env with process-specific env
+	* Process-specific env variables override global ones
+	*/
+	getEnvVars(processKey) {
+		const globalEnv = this.env.get("global") ?? {};
+		if (!processKey) return { ...globalEnv };
+		const processEnv = this.env.get(processKey) ?? {};
+		return {
+			...globalEnv,
+			...processEnv
+		};
+	}
+	/**
+	* Get all loaded env maps (for debugging/inspection)
+	*/
+	getAllEnv() {
+		return this.env;
+	}
+};
+
+//#endregion
+//#region src/logger.ts
+const colors = {
+	reset: "\x1B[0m",
+	gray: "\x1B[90m",
+	white: "\x1B[37m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	red: "\x1B[31m",
+	bold: "\x1B[1m"
+};
+const levelColors = {
+	debug: colors.gray,
+	info: colors.green,
+	warn: colors.yellow,
+	error: colors.red
+};
+const formatTime = (date) => Intl.DateTimeFormat("en-US", {
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	fractionalSecondDigits: 3,
+	hourCycle: "h23"
+}).format(date);
+const formatPrefixNoColor = (level, name, time) => {
+	const levelFormatted = level.toUpperCase().padStart(5);
+	return `[${formatTime(time)}] ${levelFormatted} (${name})`;
+};
+const formatPrefixWithColor = (level, name, time) => {
+	const levelFormatted = level.toUpperCase().padStart(5);
+	const timestamp = formatTime(time);
+	const levelTint = levelColors[level] ?? "";
+	return `${colors.gray}[${timestamp}]${colors.reset} ${levelTint}${levelFormatted}${colors.reset} (${name})`;
+};
+const writeLogFile = (logFile, line) => {
+	if (!logFile) return;
+	appendFileSync(logFile, `${line}\n`);
+};
+const logLine = (config, level, args) => {
+	const message = args.length > 0 ? format(...args) : "";
+	const time = /* @__PURE__ */ new Date();
+	const plainLine = `${formatPrefixNoColor(level, config.name, time)}  ${message}`;
+	writeLogFile(config.logFile, plainLine);
+	if (!config.stdout) return;
+	const coloredLine = `${formatPrefixWithColor(level, config.name, time)}  ${message}`;
+	switch (level) {
+		case "error":
+			console.error(coloredLine);
+			break;
+		case "warn":
+			console.warn(coloredLine);
+			break;
+		case "info":
+			console.info(coloredLine);
+			break;
+		default:
+			console.debug(coloredLine);
+			break;
+	}
+};
+const logger = (input) => {
+	const config = {
+		stdout: true,
+		...input
+	};
+	return {
+		info: (...args) => logLine(config, "info", args),
+		error: (...args) => logLine(config, "error", args),
+		warn: (...args) => logLine(config, "warn", args),
+		debug: (...args) => logLine(config, "debug", args),
+		child: (suffix, overrides = {}) => logger({
+			...config,
+			...overrides,
+			name: `${config.name}:${suffix}`
+		})
+	};
+};
+
+//#endregion
+export { ProcessDefinitionSchema as _, TaskStateSchema as a, CronProcessStateSchema as c, CrashLoopConfigSchema as d, RestartPolicySchema as f, LazyProcess as g, RestartingProcessStateSchema as h, TaskList as i, RetryConfigSchema as l, RestartingProcessOptionsSchema as m, EnvManager as n, CronProcess as o, RestartingProcess as p, NamedProcessDefinitionSchema as r, CronProcessOptionsSchema as s, logger as t, BackoffStrategySchema as u, ProcessStateSchema as v };
+//# sourceMappingURL=logger-crc5neL8.mjs.map