pidnap 0.0.0-dev.4 → 0.0.0-dev.6

package/dist/{logger-BIJzGqk3.mjs → logger-BU2RmetS.mjs}

@@ -1,107 +1,22 @@
-import { basename, join, resolve } from "node:path";
+import { basename, isAbsolute, resolve } from "node:path";
 import * as v from "valibot";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { createInterface } from "node:readline/promises";
 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 { appendFileSync, existsSync, globSync, readFileSync } from "node:fs";
 import { parse } from "dotenv";
-import { readFile } from "node:fs/promises";
+import { watch } from "chokidar";
 import { format } from "node:util";
 
-//#region src/tree-kill.ts
-/**
-* Kill a process and all its descendants (children, grandchildren, etc.)
-* @param pid - The process ID to kill
-* @param signal - The signal to send (default: SIGTERM)
-* @returns Promise that resolves when all processes have been signaled
-*/
-async function treeKill(pid, signal = "SIGTERM") {
-	if (Number.isNaN(pid)) throw new Error("pid must be a number");
-	const tree = { [pid]: [] };
-	await buildProcessTree(pid, tree, new Set([pid]));
-	killAll(tree, signal);
-}
-/**
-* Build a tree of all child processes recursively
-*/
-async function buildProcessTree(parentPid, tree, pidsToProcess) {
-	return new Promise((resolve) => {
-		const ps = spawn("ps", [
-			"-o",
-			"pid",
-			"--no-headers",
-			"--ppid",
-			String(parentPid)
-		]);
-		let allData = "";
-		ps.stdout.on("data", (data) => {
-			allData += data.toString("ascii");
-		});
-		ps.on("close", async (code) => {
-			pidsToProcess.delete(parentPid);
-			if (code !== 0) {
-				if (pidsToProcess.size === 0) resolve();
-				return;
-			}
-			const childPids = allData.match(/\d+/g);
-			if (!childPids) {
-				if (pidsToProcess.size === 0) resolve();
-				return;
-			}
-			const promises = [];
-			for (const pidStr of childPids) {
-				const childPid = parseInt(pidStr, 10);
-				tree[parentPid].push(childPid);
-				tree[childPid] = [];
-				pidsToProcess.add(childPid);
-				promises.push(buildProcessTree(childPid, tree, pidsToProcess));
-			}
-			await Promise.all(promises);
-			if (pidsToProcess.size === 0) resolve();
-		});
-		ps.on("error", () => {
-			pidsToProcess.delete(parentPid);
-			if (pidsToProcess.size === 0) resolve();
-		});
-	});
-}
-/**
-* Kill all processes in the tree
-* Kills children before parents to ensure clean shutdown
-*/
-function killAll(tree, signal) {
-	const killed = /* @__PURE__ */ new Set();
-	const allPids = Object.keys(tree).map(Number);
-	for (const pid of allPids) for (const childPid of tree[pid]) if (!killed.has(childPid)) {
-		killPid(childPid, signal);
-		killed.add(childPid);
-	}
-	for (const pid of allPids) if (!killed.has(pid)) {
-		killPid(pid, signal);
-		killed.add(pid);
-	}
-}
-/**
-* Kill a single process, ignoring ESRCH errors (process already dead)
-*/
-function killPid(pid, signal) {
-	try {
-		process.kill(pid, signal);
-	} catch (err) {
-		if (err.code !== "ESRCH") throw err;
-	}
-}
-
-//#endregion
 //#region src/lazy-process.ts
-const ProcessDefinitionSchema = v.object({
+const ProcessDefinition = 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([
+const ProcessState = v.picklist([
 	"idle",
 	"starting",
 	"running",
@@ -110,21 +25,17 @@ const ProcessStateSchema = v.picklist([
 	"error"
 ]);
 /**
-* Kill a process and all its descendants (children, grandchildren, etc.)
-* Falls back to simple child.kill() if tree kill fails.
+* Kill a process group (the process and all its descendants).
+* Uses negative PID to target the entire process group.
 */
-async function killProcessTree(child, signal) {
-	const pid = child.pid;
-	if (pid === void 0) return false;
+function killProcessGroup(pid, signal) {
 	try {
-		await treeKill(pid, signal);
+		process.kill(-pid, signal);
 		return true;
-	} catch {
-		try {
-			return child.kill(signal);
-		} catch {
-			return false;
-		}
+	} catch (err) {
+		const code = err.code;
+		if (code === "ESRCH" || code === "EPERM") return true;
+		return false;
 	}
 }
 var LazyProcess = class {
@@ -138,17 +49,17 @@ var LazyProcess = class {
 	constructor(name, definition, logger) {
 		this.name = name;
 		this.definition = definition;
-		this.logger = logger;
+		this.logger = logger.withPrefix("SYS");
 	}
 	get state() {
 		return this._state;
 	}
-	start() {
+	async 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.processExit = Promise.withResolvers();
-		this.logger.info(`Starting process: ${this.definition.command}`);
+		this.logger.debug(`Starting process: ${this.definition.command}`);
 		try {
 			const env = this.definition.env ? {
 				...process.env,
@@ -161,28 +72,20 @@ var LazyProcess = class {
 					"ignore",
 					"pipe",
 					"pipe"
-				]
+				],
+				detached: true
 			});
 			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();
-				});
+				const rl = createInterface({ input: this.childProcess.stdout });
+				rl.on("line", (line) => this.logger.withPrefix("OUT").info(line));
+				this.processExit.promise.then(() => rl.close());
 			}
 			if (this.childProcess.stderr) {
-				streamCount++;
-				this.childProcess.stderr.pipe(combined, { end: false });
-				this.childProcess.stderr.on("end", () => {
-					if (--streamCount === 0) combined.end();
-				});
+				const rl = createInterface({ input: this.childProcess.stderr });
+				rl.on("line", (line) => this.logger.withPrefix("ERR").info(line));
+				this.processExit.promise.then(() => rl.close());
 			}
-			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) {
@@ -221,28 +124,24 @@ var LazyProcess = class {
 			return;
 		}
 		this._state = "stopping";
-		this.logger.info(`Stopping process with SIGTERM`);
-		await killProcessTree(this.childProcess, "SIGTERM");
+		const pid = this.childProcess.pid;
+		if (pid === void 0) {
+			this._state = "stopped";
+			this.cleanup();
+			return;
+		}
+		this.logger.debug(`Stopping process group (pid: ${pid}) with SIGTERM`);
 		const timeoutMs = timeout ?? 5e3;
-		const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), timeoutMs));
-		this.logger.info(`Waiting for process exit (timeout: ${timeoutMs}ms)`);
-		const result = await Promise.race([this.processExit.promise.then(() => "exited"), timeoutPromise]);
-		this.logger.info(`Stop race result: ${result}`);
-		if (result === "timeout" && this.childProcess) {
-			const pid = this.childProcess.pid;
+		const resultRace = Promise.race([this.processExit.promise.then(() => "exited"), setTimeout$1(timeoutMs, "timeout")]);
+		killProcessGroup(pid, "SIGTERM");
+		this.logger.debug(`Waiting for process exit (timeout: ${timeoutMs}ms)`);
+		const result = await resultRace;
+		this.logger.debug(`process exit result: ${result}`);
+		if (result === "timeout") {
 			this.logger.warn(`Process did not exit within ${timeoutMs}ms, sending SIGKILL (pid: ${pid})`);
-			const killed = await killProcessTree(this.childProcess, "SIGKILL");
-			this.logger.info(`SIGKILL sent via tree-kill: ${killed ? "success" : "failed"}`);
-			if (!killed && this.childProcess) {
-				this.logger.warn(`Tree-kill failed, attempting direct SIGKILL`);
-				try {
-					this.childProcess.kill("SIGKILL");
-					this.logger.info(`Direct SIGKILL sent`);
-				} catch (err) {
-					this.logger.error(`Direct SIGKILL failed:`, err);
-				}
-			}
-			const killTimeout = new Promise((resolve) => setTimeout(resolve, 1e3));
+			const killed = killProcessGroup(pid, "SIGKILL");
+			this.logger.info(`SIGKILL sent to process group: ${killed ? "success" : "failed"}`);
+			const killTimeout = setTimeout$1(1e3, "timeout");
 			await Promise.race([this.processExit.promise, killTimeout]);
 			if (this.childProcess && !this.childProcess.killed) this.logger.error(`Process still alive after SIGKILL (pid: ${pid})`);
 		}
@@ -251,8 +150,8 @@ var LazyProcess = class {
 		this.logger.info(`Process stopped`);
 	}
 	async reset() {
-		if (this.childProcess) {
-			await killProcessTree(this.childProcess, "SIGKILL");
+		if (this.childProcess?.pid !== void 0) {
+			killProcessGroup(this.childProcess.pid, "SIGKILL");
 			await this.processExit.promise;
 			this.cleanup();
 		}
@@ -270,8 +169,6 @@ var LazyProcess = class {
 	}
 	cleanup() {
 		if (this.childProcess) {
-			this.childProcess.stdout?.removeAllListeners();
-			this.childProcess.stderr?.removeAllListeners();
 			this.childProcess.removeAllListeners();
 			this.childProcess = null;
 		}
@@ -281,14 +178,14 @@ var LazyProcess = class {
 
 //#endregion
 //#region src/restarting-process.ts
-const RestartPolicySchema = v.picklist([
+const RestartPolicy = v.picklist([
 	"always",
 	"on-failure",
 	"never",
 	"unless-stopped",
 	"on-success"
 ]);
-const BackoffStrategySchema = v.union([v.object({
+const BackoffStrategy = v.union([v.object({
 	type: v.literal("fixed"),
 	delayMs: v.number()
 }), v.object({
@@ -297,19 +194,19 @@ const BackoffStrategySchema = v.union([v.object({
 	maxDelayMs: v.number(),
 	multiplier: v.optional(v.number())
 })]);
-const CrashLoopConfigSchema = v.object({
+const CrashLoopConfig = 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),
+const RestartingProcessOptions = v.object({
+	restartPolicy: RestartPolicy,
+	backoff: v.optional(BackoffStrategy),
+	crashLoop: v.optional(CrashLoopConfig),
 	minUptimeMs: v.optional(v.number()),
 	maxTotalRestarts: v.optional(v.number())
 });
-const RestartingProcessStateSchema = v.picklist([
+const RestartingProcessState = v.picklist([
 	"idle",
 	"running",
 	"restarting",
@@ -330,7 +227,6 @@ const DEFAULT_CRASH_LOOP = {
 var RestartingProcess = class {
 	name;
 	lazyProcess;
-	definition;
 	options;
 	logger;
 	_state = "idle";
@@ -342,7 +238,6 @@ var RestartingProcess = class {
 	pendingDelayTimeout = null;
 	constructor(name, definition, options, logger) {
 		this.name = name;
-		this.definition = definition;
 		this.logger = logger;
 		this.options = {
 			restartPolicy: options.restartPolicy,
@@ -407,7 +302,6 @@ var RestartingProcess = class {
 	*/
 	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);
 	}
@@ -433,9 +327,9 @@ var RestartingProcess = class {
 	startProcess() {
 		this.lastStartTime = Date.now();
 		this._state = "running";
-		this.lazyProcess.reset().then(() => {
+		this.lazyProcess.reset().then(async () => {
 			if (this.stopRequested) return;
-			this.lazyProcess.start();
+			await this.lazyProcess.start();
 			return this.lazyProcess.waitForExit();
 		}).then((exitState) => {
 			if (!exitState) return;
@@ -542,16 +436,16 @@ var RestartingProcess = class {
 
 //#endregion
 //#region src/cron-process.ts
-const RetryConfigSchema = v.object({
+const RetryConfig = v.object({
 	maxRetries: v.number(),
 	delayMs: v.optional(v.number())
 });
-const CronProcessOptionsSchema = v.object({
+const CronProcessOptions = v.object({
 	schedule: v.string(),
-	retry: v.optional(RetryConfigSchema),
+	retry: v.optional(RetryConfig),
 	runOnStart: v.optional(v.boolean())
 });
-const CronProcessStateSchema = v.picklist([
+const CronProcessState = v.picklist([
 	"idle",
 	"scheduled",
 	"running",
@@ -657,7 +551,7 @@ var CronProcess = class {
 	async runJobWithRetry() {
 		if (this.stopRequested) return;
 		await this.lazyProcess.reset();
-		this.lazyProcess.start();
+		await this.lazyProcess.start();
 		const exitState = await this.lazyProcess.waitForExit();
 		if (this.stopRequested && exitState === "error") {
 			this._state = "stopped";
@@ -715,7 +609,7 @@ const TaskStateSchema = v.picklist([
 ]);
 const NamedProcessDefinitionSchema = v.object({
 	name: v.string(),
-	process: ProcessDefinitionSchema
+	process: ProcessDefinition
 });
 var TaskList = class {
 	name;
@@ -828,7 +722,7 @@ var TaskList = class {
 		});
 		this.runningProcesses = lazyProcesses;
 		try {
-			for (const lp of lazyProcesses) lp.start();
+			await Promise.all(lazyProcesses.map((lp) => 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) {
@@ -853,67 +747,96 @@ var TaskList = class {
 //#endregion
 //#region src/env-manager.ts
 var EnvManager = class {
+	globalEnv = {};
+	globalEnvPath;
 	env = /* @__PURE__ */ new Map();
-	cwd;
-	watchEnabled;
 	watchers = /* @__PURE__ */ new Map();
-	fileToKeys = /* @__PURE__ */ new Map();
+	fileToKey = /* @__PURE__ */ new Map();
 	changeCallbacks = /* @__PURE__ */ new Set();
-	reloadDebounceTimers = /* @__PURE__ */ new Map();
-	constructor(config = {}) {
-		this.cwd = config.cwd ?? process.cwd();
-		this.watchEnabled = config.watch ?? false;
+	cwdWatcher = null;
+	customKeys = /* @__PURE__ */ new Set();
+	constructor(config) {
+		this.config = config;
+		this.globalEnvPath = config.globalEnvFile ? isAbsolute(config.globalEnvFile) ? config.globalEnvFile : resolve(config.cwd, config.globalEnvFile) : resolve(config.cwd, ".env");
+		this.loadCustomEnvFiles();
 		this.loadEnvFilesFromCwd();
-		if (config.files) for (const [key, filePath] of Object.entries(config.files)) this.loadEnvFile(key, filePath);
+		this.watchCwdForNewFiles();
 	}
+	/**
+	* Register a custom env file for a key.
+	* Once registered, auto-discovered .env.{key} files will be ignored for this key.
+	*/
 	registerFile(key, filePath) {
-		this.loadEnvFile(key, filePath);
+		const absolutePath = isAbsolute(filePath) ? filePath : resolve(this.config.cwd, filePath);
+		this.customKeys.add(key);
+		this.loadEnvFile(key, absolutePath);
 	}
-	getEnvForKey(key) {
-		return this.env.get(key) ?? {};
+	/**
+	* Check if a key has a custom env file registered
+	*/
+	hasCustomFile(key) {
+		return this.customKeys.has(key);
 	}
 	/**
-	* Load .env and .env.* files from the cwd
+	* Load custom env files from config
 	*/
+	loadCustomEnvFiles() {
+		if (!this.config.customEnvFiles) return;
+		for (const [key, filePath] of Object.entries(this.config.customEnvFiles)) this.registerFile(key, filePath);
+	}
+	getEnvVars(key) {
+		const specificEnv = this.env.get(key);
+		return {
+			...this.globalEnv,
+			...specificEnv
+		};
+	}
 	loadEnvFilesFromCwd() {
-		const dotEnvPath = resolve(this.cwd, ".env");
-		if (existsSync(dotEnvPath)) this.loadEnvFile("global", dotEnvPath);
+		if (existsSync(this.globalEnvPath)) this.loadGlobalEnv(this.globalEnvPath);
 		try {
-			const envFiles = globSync(join(this.cwd, ".env.*"));
+			const envFiles = globSync(".env.*", { cwd: this.config.cwd });
 			for (const filePath of envFiles) {
-				const match = basename(filePath).match(/^\.env\.(.+)$/);
-				if (match) {
-					const suffix = match[1];
-					this.loadEnvFile(suffix, filePath);
-				}
+				const key = this.getEnvKeySuffix(basename(filePath));
+				if (key && !this.customKeys.has(key)) this.loadEnvFile(key, resolve(this.config.cwd, 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;
+	parseEnvFile(absolutePath) {
 		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);
+			return parse(readFileSync(absolutePath, "utf-8")) ?? {};
 		} catch (err) {
-			console.warn(`Failed to load env file: ${absolutePath}`, err);
+			console.warn(`Failed to parse env file: ${absolutePath}`, err);
+			return null;
 		}
 	}
-	/**
-	* Watch a file for changes
-	*/
+	getEnvKeySuffix(fileName) {
+		const match = fileName.match(/^\.env\.(.+)$/);
+		return match ? match[1] : null;
+	}
+	loadGlobalEnv(absolutePath) {
+		if (!existsSync(absolutePath)) return;
+		const parsed = this.parseEnvFile(absolutePath);
+		if (parsed) {
+			this.globalEnv = parsed;
+			this.watchFile(absolutePath);
+		}
+	}
+	loadEnvFile(key, absolutePath) {
+		const parsed = this.parseEnvFile(absolutePath);
+		if (!parsed) return;
+		this.env.set(key, parsed);
+		this.fileToKey.set(absolutePath, key);
+		this.watchFile(absolutePath);
+	}
 	watchFile(absolutePath) {
+		if (this.watchers.has(absolutePath)) return;
 		try {
-			const watcher = watch(absolutePath, (eventType) => {
-				if (eventType === "change") this.handleFileChange(absolutePath);
+			const watcher = watch(absolutePath, { ignoreInitial: true }).on("change", () => {
+				this.handleFileChange(absolutePath);
+			}).on("unlink", () => {
+				this.handleFileDelete(absolutePath);
 			});
 			this.watchers.set(absolutePath, watcher);
 		} catch (err) {
@@ -921,74 +844,91 @@ var EnvManager = class {
 		}
 	}
 	/**
-	* Handle file change with debouncing
+	* Watch cwd for new .env.* files
 	*/
-	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);
+	watchCwdForNewFiles() {
+		try {
+			this.cwdWatcher = watch(this.config.cwd, {
+				ignoreInitial: true,
+				depth: 0
+			}).on("add", (filePath) => {
+				this.handleNewFile(filePath);
+			});
+		} catch (err) {
+			console.warn(`Failed to watch cwd for new env files:`, err);
+		}
 	}
-	/**
-	* 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);
+	handleFileChange(absolutePath) {
+		if (absolutePath === this.globalEnvPath) {
+			this.loadGlobalEnv(absolutePath);
+			this.notifyCallbacks({ type: "global" });
+			return;
+		}
+		const key = this.fileToKey.get(absolutePath);
+		if (!key) return;
+		const parsed = this.parseEnvFile(absolutePath);
+		if (!parsed) return;
+		this.env.set(key, parsed);
+		this.notifyCallbacks({
+			type: "process",
+			key
 		});
 	}
-	/**
-	* Register a callback to be called when env files change
-	* Returns a function to unregister the callback
-	*/
+	handleFileDelete(absolutePath) {
+		const watcher = this.watchers.get(absolutePath);
+		if (watcher) {
+			watcher.close();
+			this.watchers.delete(absolutePath);
+		}
+		if (absolutePath === this.globalEnvPath) {
+			this.globalEnv = {};
+			this.notifyCallbacks({ type: "global" });
+			return;
+		}
+		const key = this.fileToKey.get(absolutePath);
+		if (key) {
+			this.env.delete(key);
+			this.fileToKey.delete(absolutePath);
+			this.notifyCallbacks({
+				type: "process",
+				key
+			});
+		}
+	}
+	handleNewFile(filePath) {
+		const absolutePath = isAbsolute(filePath) ? filePath : resolve(this.config.cwd, filePath);
+		if (absolutePath === this.globalEnvPath) {
+			this.loadGlobalEnv(absolutePath);
+			this.notifyCallbacks({ type: "global" });
+			return;
+		}
+		const key = this.getEnvKeySuffix(basename(filePath));
+		if (key && !this.customKeys.has(key) && !this.env.has(key)) {
+			this.loadEnvFile(key, absolutePath);
+			this.notifyCallbacks({
+				type: "process",
+				key
+			});
+		}
+	}
+	notifyCallbacks(event) {
+		for (const callback of this.changeCallbacks) callback(event);
+	}
 	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();
+	close() {
 		for (const watcher of this.watchers.values()) watcher.close();
 		this.watchers.clear();
+		if (this.cwdWatcher) {
+			this.cwdWatcher.close();
+			this.cwdWatcher = null;
+		}
 		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
@@ -1025,36 +965,37 @@ const formatPrefixWithColor = (level, name, 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 formatMessagePrefix = (prefix, colored) => {
+	if (!prefix) return "";
+	if (colored) return `${colors.bold}${colors.white}[${prefix}]${colors.reset} `;
+	return `[${prefix}]`;
 };
 const logLine = (config, level, args) => {
-	const message = args.length > 0 ? format(...args) : "";
+	const message = 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;
+	if (config.logFile) {
+		const plainLine = [
+			formatPrefixNoColor(level, config.name, time),
+			formatMessagePrefix(config.prefix, false),
+			message
+		].filter(Boolean).join(" ");
+		try {
+			appendFileSync(config.logFile, `${plainLine}\n`);
+		} catch {}
+	}
+	if (config.stdout) {
+		const coloredLine = [
+			formatPrefixWithColor(level, config.name, time),
+			formatMessagePrefix(config.prefix, true),
+			message
+		].filter(Boolean).join(" ");
+		console[level](coloredLine);
 	}
 };
-const logger = (input) => {
+const logger = (_config) => {
 	const config = {
 		stdout: true,
-		...input
+		..._config
 	};
 	return {
 		info: (...args) => logLine(config, "info", args),
@@ -1065,10 +1006,14 @@ const logger = (input) => {
 			...config,
 			...overrides,
 			name: `${config.name}:${suffix}`
+		}),
+		withPrefix: (prefix) => logger({
+			...config,
+			prefix
 		})
 	};
 };
 
 //#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, treeKill as y };
-//# sourceMappingURL=logger-BIJzGqk3.mjs.map
+export { ProcessDefinition as _, TaskStateSchema as a, CronProcessState as c, CrashLoopConfig as d, RestartPolicy as f, LazyProcess as g, RestartingProcessState as h, TaskList as i, RetryConfig as l, RestartingProcessOptions as m, EnvManager as n, CronProcess as o, RestartingProcess as p, NamedProcessDefinitionSchema as r, CronProcessOptions as s, logger as t, BackoffStrategy as u, ProcessState as v };
+//# sourceMappingURL=logger-BU2RmetS.mjs.map