pid1 0.0.0-dev.0

package/dist/process-manager-gO56266Q.mjs

@@ -0,0 +1,643 @@
+import { a as processLogger, i as globalLogger, r as loadConfigFile } from "./config-BgRb4pSG.mjs";
+import { dirname, join } from "node:path";
+import { existsSync, readFileSync, watch } from "node:fs";
+import * as v from "valibot";
+import { parse } from "dotenv";
+import { x } from "tinyexec";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { RPCHandler } from "@orpc/server/fetch";
+import { ORPCError, onError, os } from "@orpc/server";
+import { logger } from "hono/logger";
+
+//#region src/env.ts
+const logger$1 = globalLogger.child("env");
+function loadEnvFile(path) {
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = parse(readFileSync(path, "utf-8"));
+		logger$1.debug(`Loaded env file: ${path}`);
+		return parsed;
+	} catch (error) {
+		logger$1.warn(`Failed to parse env file ${path}: ${error}`);
+		return {};
+	}
+}
+function loadEnvForProcess(options) {
+	const { configDir, processName, globalEnvFile, processEnvFile, configEnv = {} } = options;
+	const baseEnv = Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== void 0));
+	let globalEnv = {};
+	if (globalEnvFile !== false) globalEnv = loadEnvFile(globalEnvFile ?? join(configDir, ".env"));
+	let processEnv = {};
+	if (processEnvFile !== false) processEnv = loadEnvFile(processEnvFile ?? join(configDir, `.env.${processName}`));
+	return {
+		...baseEnv,
+		...globalEnv,
+		...configEnv,
+		...processEnv
+	};
+}
+
+//#endregion
+//#region src/exec.ts
+function spawnWithLogging({ name, command, args, env, cwd, logFile, abortSignal, type }) {
+	const proc = x(command, args, {
+		nodeOptions: {
+			cwd,
+			env
+		},
+		signal: abortSignal,
+		throwOnError: true
+	});
+	const kill = (signal = "SIGTERM") => {
+		if (proc.pid) try {
+			process.kill(proc.pid, signal);
+			return true;
+		} catch {
+			return false;
+		}
+		return false;
+	};
+	return {
+		proc,
+		done: (async () => {
+			const logger = processLogger({
+				name: `${type}:${name}`,
+				logFile
+			});
+			logger.info(`Starting: command=${command}, args=[${args.join(", ")}], cwd=${cwd}`);
+			for await (const line of proc) logger.info(line);
+			await proc;
+			const exitCode = proc.exitCode;
+			if (proc.aborted || proc.killed || exitCode === null || exitCode === void 0) logger.info(`${name} was terminated`);
+			else if (exitCode === 0) logger.info(`${name} completed successfully`);
+			else logger.info(`${name} exited with code ${exitCode}`);
+			return proc.exitCode ?? null;
+		})(),
+		kill
+	};
+}
+
+//#endregion
+//#region src/api/router.ts
+const ProcessInfoSchema = v.object({
+	id: v.number(),
+	name: v.string(),
+	status: v.picklist([
+		"stopped",
+		"running",
+		"errored"
+	]),
+	pid: v.optional(v.number()),
+	exitCode: v.nullable(v.number()),
+	restarts: v.number(),
+	startedAt: v.nullable(v.date()),
+	command: v.string(),
+	args: v.array(v.string())
+});
+const ProcessNameSchema = v.object({ name: v.string() });
+const base = os.$context();
+const list = base.output(v.array(ProcessInfoSchema)).handler(async ({ context }) => {
+	return context.pm.list();
+});
+const get = base.input(ProcessNameSchema).output(v.nullable(ProcessInfoSchema)).handler(async ({ input, context }) => {
+	return context.pm.get(input.name) ?? null;
+});
+const start = base.input(v.object({ name: v.optional(v.string()) })).output(v.object({
+	success: v.boolean(),
+	message: v.string()
+})).handler(async ({ input, context }) => {
+	try {
+		if (input.name) {
+			context.pm.start(input.name);
+			return {
+				success: true,
+				message: `Started process: ${input.name}`
+			};
+		} else {
+			context.pm.startAll();
+			return {
+				success: true,
+				message: "Started all processes"
+			};
+		}
+	} catch (error) {
+		throw new ORPCError("BAD_REQUEST", { message: error instanceof Error ? error.message : "Failed to start" });
+	}
+});
+const stop = base.input(v.object({ name: v.optional(v.string()) })).output(v.object({
+	success: v.boolean(),
+	message: v.string()
+})).handler(async ({ input, context }) => {
+	try {
+		if (input.name) {
+			await context.pm.stop(input.name);
+			return {
+				success: true,
+				message: `Stopped process: ${input.name}`
+			};
+		} else {
+			await context.pm.stopAll();
+			return {
+				success: true,
+				message: "Stopped all processes"
+			};
+		}
+	} catch (error) {
+		throw new ORPCError("BAD_REQUEST", { message: error instanceof Error ? error.message : "Failed to stop" });
+	}
+});
+const restart = base.input(v.object({ name: v.optional(v.string()) })).output(v.object({
+	success: v.boolean(),
+	message: v.string()
+})).handler(async ({ input, context }) => {
+	try {
+		if (input.name) {
+			await context.pm.restart(input.name);
+			return {
+				success: true,
+				message: `Restarted process: ${input.name}`
+			};
+		} else {
+			await context.pm.restartAll();
+			return {
+				success: true,
+				message: "Restarted all processes"
+			};
+		}
+	} catch (error) {
+		throw new ORPCError("BAD_REQUEST", { message: error instanceof Error ? error.message : "Failed to restart" });
+	}
+});
+const deleteProcess = base.input(v.object({ name: v.optional(v.string()) })).output(v.object({
+	success: v.boolean(),
+	message: v.string()
+})).handler(async ({ input, context }) => {
+	try {
+		if (input.name) {
+			await context.pm.delete(input.name);
+			return {
+				success: true,
+				message: `Deleted process: ${input.name}`
+			};
+		} else {
+			await context.pm.deleteAll();
+			return {
+				success: true,
+				message: "Deleted all processes"
+			};
+		}
+	} catch (error) {
+		throw new ORPCError("BAD_REQUEST", { message: error instanceof Error ? error.message : "Failed to delete" });
+	}
+});
+const health = os.output(v.object({ status: v.literal("ok") })).handler(async () => {
+	return { status: "ok" };
+});
+const router = {
+	health,
+	process: {
+		list,
+		get,
+		start,
+		stop,
+		restart,
+		delete: deleteProcess
+	}
+};
+
+//#endregion
+//#region src/api/server.ts
+function createServer(pm, options = {}) {
+	const { port = 3e3, host = "127.0.0.1" } = options;
+	const logger$2 = globalLogger.child("server");
+	const app = new Hono();
+	const handler = new RPCHandler(router, { interceptors: [onError((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		logger$2.error(`RPC Error: ${message}`);
+	})] });
+	app.use(logger((msg, ...args) => logger$2.debug(`${msg} ${args.join(" ")}`)));
+	app.get("/health", (c) => c.json({ status: "ok" }));
+	app.use("/rpc/*", async (c, next) => {
+		const { matched, response } = await handler.handle(c.req.raw, {
+			prefix: "/rpc",
+			context: { pm }
+		});
+		if (matched) return c.newResponse(response.body, response);
+		await next();
+	});
+	app.notFound((c) => c.json({ error: "Not found" }, 404));
+	return {
+		app,
+		start: () => {
+			const server = serve({
+				fetch: app.fetch,
+				port,
+				hostname: host
+			});
+			logger$2.info(`HTTP server listening on http://${host}:${port}`);
+			logger$2.info(`RPC endpoint: http://${host}:${port}/rpc`);
+			return server;
+		}
+	};
+}
+
+//#endregion
+//#region src/process-manager.ts
+const DEFAULT_STOP_TIMEOUT_MS = 1e4;
+const DEFAULT_RESTART_RESET_SECONDS = 300;
+const DEFAULT_RESTART_MAX = 10;
+const DEFAULT_RESTART_MIN_DELAY_MS = 5e3;
+const DEFAULT_RESTART_MAX_DELAY_MS = 6e4;
+var ProcessManager = class {
+	logger = globalLogger.child("pm");
+	cwd;
+	configPath;
+	configDir;
+	globalEnvFile;
+	processes;
+	processIds;
+	nextProcessId = 0;
+	signalHandlersSetup = false;
+	serverOptions;
+	httpServer;
+	envWatcher = null;
+	envChangeTimers = /* @__PURE__ */ new Map();
+	envRestartTimers = /* @__PURE__ */ new Map();
+	restartOnEnvChangeGlobal = true;
+	restartMinDelayMsGlobal = DEFAULT_RESTART_MIN_DELAY_MS;
+	restartMaxDelayMsGlobal = DEFAULT_RESTART_MAX_DELAY_MS;
+	currentTask = null;
+	currentTaskName = null;
+	taskAbortController = null;
+	constructor(options = {}) {
+		this.cwd = options.cwd ?? process.cwd();
+		this.configPath = options.configPath;
+		this.processes = /* @__PURE__ */ new Map();
+		this.processIds = /* @__PURE__ */ new Map();
+		this.serverOptions = options.server;
+	}
+	async init() {
+		const config = await loadConfigFile(this.configPath, this.cwd);
+		this.configDir = dirname(config.configPath);
+		this.globalEnvFile = config.envFile;
+		this.restartOnEnvChangeGlobal = config.restartOnEnvChange ?? true;
+		this.restartMinDelayMsGlobal = config.restartMinDelayMs ?? DEFAULT_RESTART_MIN_DELAY_MS;
+		this.restartMaxDelayMsGlobal = config.restartMaxDelayMs ?? DEFAULT_RESTART_MAX_DELAY_MS;
+		this.logger.info(`Executing ${config.tasks.length} tasks and registering ${config.processes.length} processes`);
+		this.setupSignalHandlers();
+		this.setupEnvWatchers();
+		await this.runTasks(config.tasks);
+		for (const p of config.processes) this.register(p);
+	}
+	register(config) {
+		if (this.processes.has(config.name)) throw new Error(`Process ${config.name} already registered`);
+		const id = this.nextProcessId++;
+		const managed = {
+			id,
+			config,
+			status: "stopped",
+			spawned: null,
+			exitCode: null,
+			restarts: 0,
+			restartAttempts: 0,
+			restartTimer: null,
+			stopRequested: false,
+			startedAt: null
+		};
+		this.processes.set(config.name, managed);
+		this.processIds.set(id, config.name);
+		this.logger.info(`Registered process: ${config.name} (id: ${id})`);
+	}
+	list() {
+		return [...this.processes.values()].map((m) => ({
+			id: m.id,
+			name: m.config.name,
+			status: m.status,
+			pid: m.spawned?.proc.pid,
+			exitCode: m.exitCode,
+			restarts: m.restarts,
+			startedAt: m.startedAt,
+			command: m.config.command,
+			args: m.config.args
+		}));
+	}
+	start(name) {
+		const { name: resolvedName, managed } = this.resolveProcessIdentifier(name);
+		if (managed.status === "running") {
+			this.logger.warn(`Process ${resolvedName} is already running`);
+			return;
+		}
+		this.spawnProcess(managed);
+	}
+	startAll() {
+		this.setupSignalHandlers();
+		for (const [_, managed] of this.processes) if (managed.status !== "running") this.spawnProcess(managed);
+	}
+	serve(options) {
+		const serverOpts = {
+			...this.serverOptions,
+			...options
+		};
+		if (serverOpts.enabled === false) return;
+		const { enabled: _enabled, ...serverOptions } = serverOpts;
+		this.httpServer = createServer(this, serverOptions).start();
+	}
+	async stop(name, timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
+		const { name: resolvedName, managed } = this.resolveProcessIdentifier(name);
+		managed.stopRequested = true;
+		this.clearRestartTimer(managed);
+		if (managed.status !== "running" || !managed.spawned) {
+			this.logger.warn(`Process ${resolvedName} is not running`);
+			return;
+		}
+		const { spawned } = managed;
+		this.logger.info(`Stopping process: ${resolvedName} (SIGTERM)`);
+		spawned.kill("SIGTERM");
+		if (!await Promise.race([spawned.done.then(() => true).catch(() => true), new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))]) && managed.status === "running") {
+			this.logger.warn(`Process ${resolvedName} did not stop gracefully, sending SIGKILL`);
+			spawned.kill("SIGKILL");
+			await spawned.done.catch(() => {});
+		}
+	}
+	async stopAll() {
+		this.logger.info("Stopping all processes...");
+		for (const managed of this.processes.values()) {
+			managed.stopRequested = true;
+			this.clearRestartTimer(managed);
+		}
+		const stopPromises = [...this.processes.entries()].filter(([, m]) => m.status === "running").map(([name]) => this.stop(name));
+		await Promise.allSettled(stopPromises);
+	}
+	async restart(name) {
+		const { name: resolvedName, managed } = this.resolveProcessIdentifier(name);
+		this.logger.info(`Restarting process: ${resolvedName}`);
+		if (managed.status === "running") await this.stop(resolvedName);
+		managed.restarts++;
+		this.spawnProcess(managed);
+	}
+	async restartAll() {
+		this.logger.info("Restarting all processes...");
+		for (const [name] of this.processes) await this.restart(name);
+	}
+	async delete(name) {
+		const { name: resolvedName, managed } = this.resolveProcessIdentifier(name);
+		managed.stopRequested = true;
+		this.clearRestartTimer(managed);
+		if (managed.status === "running") await this.stop(resolvedName);
+		this.processes.delete(resolvedName);
+		this.processIds.delete(managed.id);
+		this.logger.info(`Deleted process: ${resolvedName}`);
+	}
+	async deleteAll() {
+		await this.stopAll();
+		this.processes.clear();
+		this.logger.info("Deleted all processes");
+	}
+	get(name) {
+		let resolved;
+		try {
+			resolved = this.resolveProcessIdentifier(name);
+		} catch {
+			return;
+		}
+		return {
+			id: resolved.managed.id,
+			name: resolved.managed.config.name,
+			status: resolved.managed.status,
+			pid: resolved.managed.spawned?.proc.pid,
+			exitCode: resolved.managed.exitCode,
+			restarts: resolved.managed.restarts,
+			startedAt: resolved.managed.startedAt,
+			command: resolved.managed.config.command,
+			args: resolved.managed.config.args
+		};
+	}
+	async wait() {
+		const donePromises = [...this.processes.values()].filter((m) => m.spawned).map((m) => m.spawned.done);
+		await Promise.allSettled(donePromises);
+		this.logger.info("All processes exited");
+	}
+	async shutdown() {
+		await this.stopActiveTask();
+		await this.stopAll();
+		this.closeEnvWatcher();
+		if (this.httpServer) {
+			this.httpServer.close();
+			this.logger.info("HTTP server closed");
+		}
+	}
+	spawnProcess(managed) {
+		const { config } = managed;
+		managed.stopRequested = false;
+		this.clearRestartTimer(managed);
+		const env = loadEnvForProcess({
+			configDir: this.configDir ?? this.cwd,
+			processName: config.name,
+			globalEnvFile: this.globalEnvFile,
+			processEnvFile: config.envFile,
+			configEnv: config.env
+		});
+		const spawned = spawnWithLogging({
+			cwd: config.cwd ?? this.cwd,
+			logFile: join(this.cwd, "logs", "processes", `${config.name}.log`),
+			type: "process",
+			name: config.name,
+			command: config.command,
+			args: config.args,
+			env
+		});
+		managed.spawned = spawned;
+		managed.status = "running";
+		managed.startedAt = /* @__PURE__ */ new Date();
+		managed.exitCode = null;
+		this.logger.info(`Started process: ${config.name} (pid: ${spawned.proc.pid})`);
+		const handleExit = (exitCode, error) => {
+			managed.exitCode = exitCode;
+			managed.status = exitCode === null || exitCode === void 0 || exitCode === 0 ? "stopped" : "errored";
+			const now = Date.now();
+			const startedAt = managed.startedAt?.getTime() ?? now;
+			if (Math.max(0, now - startedAt) >= (config.restartResetSeconds ?? DEFAULT_RESTART_RESET_SECONDS) * 1e3) managed.restartAttempts = 0;
+			if (exitCode === null || exitCode === void 0) this.logger.info(`Process ${config.name} stopped`);
+			else if (exitCode !== 0) this.logger.info(`Process ${config.name} exited with code ${exitCode}`);
+			else this.logger.info(`Process ${config.name} exited successfully`);
+			if (error) this.logger.error(`Process ${config.name} failed with error: ${error}`);
+			const policy = config.restartPolicy ?? "on-failure";
+			const isFailure = exitCode === null || exitCode === void 0 || exitCode !== 0;
+			if (!(!managed.stopRequested && (policy === "always" || policy === "on-failure" && isFailure))) return;
+			const maxRestarts = config.maxRestarts ?? DEFAULT_RESTART_MAX;
+			if (managed.restartAttempts >= maxRestarts) {
+				managed.status = "errored";
+				this.logger.warn(`Process ${config.name} reached restart limit (${maxRestarts}), not restarting`);
+				return;
+			}
+			managed.restartAttempts += 1;
+			managed.restarts += 1;
+			const minDelay = config.restartMinDelayMs ?? this.restartMinDelayMsGlobal;
+			const maxDelay = config.restartMaxDelayMs ?? this.restartMaxDelayMsGlobal;
+			const delay = Math.min(maxDelay, minDelay * Math.pow(2, managed.restartAttempts - 1));
+			this.logger.warn(`Restarting process ${config.name} in ${delay}ms (attempt ${managed.restartAttempts}/${maxRestarts})`);
+			managed.restartTimer = setTimeout(() => {
+				managed.restartTimer = null;
+				if (!managed.stopRequested) this.spawnProcess(managed);
+			}, delay);
+		};
+		spawned.done.then((exitCode) => handleExit(exitCode)).catch((error) => {
+			handleExit(spawned.proc.exitCode ?? 1, error);
+		});
+	}
+	async runTasks(tasks) {
+		for (const task of tasks) {
+			const env = loadEnvForProcess({
+				configDir: this.configDir ?? this.cwd,
+				processName: task.name,
+				globalEnvFile: this.globalEnvFile,
+				processEnvFile: task.envFile,
+				configEnv: task.env
+			});
+			const taskAbortController = new AbortController();
+			this.taskAbortController = taskAbortController;
+			const spawned = spawnWithLogging({
+				cwd: task.cwd ?? this.cwd,
+				logFile: join(this.cwd, "logs", "tasks", `${task.name}.log`),
+				type: "task",
+				name: task.name,
+				command: task.command,
+				args: task.args,
+				env,
+				abortSignal: taskAbortController.signal
+			});
+			this.currentTask = spawned;
+			this.currentTaskName = task.name;
+			let exitCode;
+			try {
+				exitCode = await spawned.done;
+			} finally {
+				this.currentTask = null;
+				this.currentTaskName = null;
+				this.taskAbortController = null;
+			}
+			if (exitCode !== 0) {
+				this.logger.error(`Task ${task.name} failed with exit code ${exitCode}`);
+				throw new Error(`Task ${task.name} failed`);
+			}
+		}
+		if (tasks.length > 0) this.logger.info("All tasks completed");
+	}
+	clearRestartTimer(managed) {
+		if (managed.restartTimer) {
+			clearTimeout(managed.restartTimer);
+			managed.restartTimer = null;
+		}
+	}
+	async stopActiveTask(timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
+		if (!this.currentTask) return;
+		const taskName = this.currentTaskName ?? "unknown";
+		this.logger.info(`Stopping task: ${taskName} (SIGTERM)`);
+		this.currentTask.kill("SIGTERM");
+		if (!await Promise.race([this.currentTask.done.then(() => true).catch(() => true), new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))])) {
+			this.logger.warn(`Task ${taskName} did not stop gracefully, sending SIGKILL`);
+			this.currentTask.kill("SIGKILL");
+			await this.currentTask.done.catch(() => {});
+		}
+	}
+	abortActiveTask(signal) {
+		if (this.taskAbortController && !this.taskAbortController.signal.aborted) this.taskAbortController.abort();
+		if (this.currentTask) this.currentTask.kill(signal);
+	}
+	setupSignalHandlers() {
+		if (this.signalHandlersSetup) return;
+		this.signalHandlersSetup = true;
+		for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+			process.stdout.write("\r\x1B[K");
+			this.logger.info(`Received ${signal}, shutting down...`);
+			this.abortActiveTask(signal);
+			this.shutdown().then(() => process.exit(0));
+		});
+	}
+	setupEnvWatchers() {
+		if (this.envWatcher) return;
+		if (!this.restartOnEnvChangeGlobal) return;
+		this.envWatcher = watch(this.configDir ?? this.cwd, (event, filename) => {
+			if (!filename) return;
+			const envFile = filename.toString();
+			if (!envFile.startsWith(".env")) return;
+			if (event !== "change" && event !== "rename") return;
+			if (envFile === ".env") {
+				this.scheduleEnvRestart("global", () => {
+					this.logger.info("Detected .env change, scheduling restarts");
+					for (const managed of this.processes.values()) this.scheduleEnvRestartForProcess(managed);
+				});
+				return;
+			}
+			if (!envFile.startsWith(".env.")) return;
+			const processName = envFile.slice(5);
+			if (!processName) return;
+			this.scheduleEnvRestart(processName, () => {
+				const managed = this.processes.get(processName);
+				if (!managed) return;
+				this.logger.info(`Detected ${envFile} change, scheduling restart for ${processName}`);
+				this.scheduleEnvRestartForProcess(managed);
+			});
+		});
+	}
+	closeEnvWatcher() {
+		if (this.envWatcher) {
+			this.envWatcher.close();
+			this.envWatcher = null;
+		}
+		for (const timer of this.envChangeTimers.values()) clearTimeout(timer);
+		this.envChangeTimers.clear();
+		for (const timer of this.envRestartTimers.values()) clearTimeout(timer);
+		this.envRestartTimers.clear();
+	}
+	scheduleEnvRestart(key, restart) {
+		const existing = this.envChangeTimers.get(key);
+		if (existing) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.envChangeTimers.delete(key);
+			restart();
+		}, 250);
+		this.envChangeTimers.set(key, timer);
+	}
+	scheduleEnvRestartForProcess(managed) {
+		if (!this.restartOnEnvChangeGlobal) return;
+		if (managed.config.restartOnEnvChange === false) return;
+		if (managed.status !== "running") return;
+		const name = managed.config.name;
+		const existing = this.envRestartTimers.get(name);
+		if (existing) clearTimeout(existing);
+		const delayMs = managed.config.restartMinDelayMs ?? this.restartMinDelayMsGlobal;
+		const timer = setTimeout(() => {
+			this.envRestartTimers.delete(name);
+			this.restart(name).catch((error) => {
+				this.logger.error(`Failed to restart ${name} after env change: ${error}`);
+			});
+		}, Math.max(0, delayMs));
+		this.envRestartTimers.set(name, timer);
+		this.logger.info(`Restarting ${name} after env change in ${Math.max(0, delayMs)}ms`);
+	}
+	resolveProcessIdentifier(nameOrId) {
+		const byName = this.processes.get(nameOrId);
+		if (byName) return {
+			name: nameOrId,
+			managed: byName
+		};
+		if (/^\d+$/.test(nameOrId)) {
+			const id = Number(nameOrId);
+			const name = this.processIds.get(id);
+			if (name) {
+				const managed = this.processes.get(name);
+				if (managed) return {
+					name,
+					managed
+				};
+			}
+		}
+		throw new Error(`Process ${nameOrId} not found`);
+	}
+};
+
+//#endregion
+export { spawnWithLogging as i, createServer as n, router as r, ProcessManager as t };
+//# sourceMappingURL=process-manager-gO56266Q.mjs.map