pidnap 0.0.0-dev.0

package/dist/cli.mjs

@@ -0,0 +1,1166 @@
+#!/usr/bin/env node
+import { _ as ProcessDefinitionSchema, a as TaskStateSchema, c as CronProcessStateSchema, h as RestartingProcessStateSchema, i as TaskList, m as RestartingProcessOptionsSchema, n as EnvManager, o as CronProcess, p as RestartingProcess, s as CronProcessOptionsSchema, t as logger } from "./logger-crc5neL8.mjs";
+import { createClient } from "./client.mjs";
+import { Command } from "commander";
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+import { join, resolve } from "node:path";
+import { RPCHandler } from "@orpc/server/node";
+import { implement, onError } from "@orpc/server";
+import * as v from "valibot";
+import { oc } from "@orpc/contract";
+import { cwd } from "node:process";
+import { mkdirSync } from "node:fs";
+import { tsImport } from "tsx/esm/api";
+import Table from "cli-table3";
+
+//#region src/api/contract.ts
+const oc$1 = oc.$input(v.void());
+const ResourceTarget = v.union([v.string(), v.number()]);
+const ManagerStateSchema = v.picklist([
+	"idle",
+	"initializing",
+	"running",
+	"stopping",
+	"stopped"
+]);
+const ManagerStatusSchema = v.object({
+	state: ManagerStateSchema,
+	processCount: v.number(),
+	cronCount: v.number(),
+	taskCount: v.number()
+});
+const RestartingProcessInfoSchema = v.object({
+	name: v.string(),
+	state: RestartingProcessStateSchema,
+	restarts: v.number()
+});
+const CronProcessInfoSchema = v.object({
+	name: v.string(),
+	state: CronProcessStateSchema,
+	runCount: v.number(),
+	failCount: v.number(),
+	nextRun: v.nullable(v.string())
+});
+const TaskEntryInfoSchema = v.object({
+	id: v.string(),
+	state: TaskStateSchema,
+	processNames: v.array(v.string())
+});
+const manager = { status: oc$1.output(ManagerStatusSchema) };
+const processes$1 = {
+	get: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
+	list: oc$1.output(v.array(RestartingProcessInfoSchema)),
+	add: oc$1.input(v.object({
+		name: v.string(),
+		definition: ProcessDefinitionSchema
+	})).output(RestartingProcessInfoSchema),
+	start: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
+	stop: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
+	restart: oc$1.input(v.object({
+		target: ResourceTarget,
+		force: v.optional(v.boolean())
+	})).output(RestartingProcessInfoSchema),
+	reload: oc$1.input(v.object({
+		target: ResourceTarget,
+		definition: ProcessDefinitionSchema,
+		restartImmediately: v.optional(v.boolean())
+	})).output(RestartingProcessInfoSchema),
+	remove: oc$1.input(v.object({ target: ResourceTarget })).output(v.object({ success: v.boolean() }))
+};
+const tasks$1 = {
+	get: oc$1.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema),
+	list: oc$1.output(v.array(TaskEntryInfoSchema)),
+	add: oc$1.input(v.object({
+		name: v.string(),
+		definition: ProcessDefinitionSchema
+	})).output(TaskEntryInfoSchema),
+	remove: oc$1.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema)
+};
+const crons$1 = {
+	get: oc$1.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
+	list: oc$1.output(v.array(CronProcessInfoSchema)),
+	trigger: oc$1.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
+	start: oc$1.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
+	stop: oc$1.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema)
+};
+const api = {
+	manager,
+	processes: processes$1,
+	tasks: tasks$1,
+	crons: crons$1
+};
+
+//#endregion
+//#region src/api/server.ts
+const os = implement(api).$context();
+function serializeProcess(proc) {
+	return {
+		name: proc.name,
+		state: proc.state,
+		restarts: proc.restarts
+	};
+}
+function serializeCron(cron) {
+	return {
+		name: cron.name,
+		state: cron.state,
+		runCount: cron.runCount,
+		failCount: cron.failCount,
+		nextRun: cron.nextRun?.toISOString() ?? null
+	};
+}
+const managerStatus = os.manager.status.handler(async ({ context }) => {
+	const manager = context.manager;
+	const taskList = manager.getTaskList();
+	return {
+		state: manager.state,
+		processCount: manager.getRestartingProcesses().size,
+		cronCount: manager.getCronProcesses().size,
+		taskCount: taskList?.tasks.length ?? 0
+	};
+});
+const getProcess = os.processes.get.handler(async ({ input, context }) => {
+	const proc = context.manager.getProcessByTarget(input.target);
+	if (!proc) throw new Error(`Process not found: ${input.target}`);
+	return serializeProcess(proc);
+});
+const listProcesses = os.processes.list.handler(async ({ context }) => {
+	return Array.from(context.manager.getRestartingProcesses().values()).map(serializeProcess);
+});
+const addProcess = os.processes.add.handler(async ({ input, context }) => {
+	return serializeProcess(context.manager.addProcess(input.name, input.definition));
+});
+const startProcess = os.processes.start.handler(async ({ input, context }) => {
+	return serializeProcess(context.manager.startProcessByTarget(input.target));
+});
+const stopProcess = os.processes.stop.handler(async ({ input, context }) => {
+	return serializeProcess(await context.manager.stopProcessByTarget(input.target));
+});
+const restartProcess = os.processes.restart.handler(async ({ input, context }) => {
+	return serializeProcess(await context.manager.restartProcessByTarget(input.target, input.force));
+});
+const reloadProcess = os.processes.reload.handler(async ({ input, context }) => {
+	return serializeProcess(await context.manager.reloadProcessByTarget(input.target, input.definition, { restartImmediately: input.restartImmediately }));
+});
+const removeProcess = os.processes.remove.handler(async ({ input, context }) => {
+	await context.manager.removeProcessByTarget(input.target);
+	return { success: true };
+});
+const getCron = os.crons.get.handler(async ({ input, context }) => {
+	const cron = context.manager.getCronByTarget(input.target);
+	if (!cron) throw new Error(`Cron not found: ${input.target}`);
+	return serializeCron(cron);
+});
+const listCrons = os.crons.list.handler(async ({ context }) => {
+	return Array.from(context.manager.getCronProcesses().values()).map(serializeCron);
+});
+const triggerCron = os.crons.trigger.handler(async ({ input, context }) => {
+	return serializeCron(await context.manager.triggerCronByTarget(input.target));
+});
+const startCron = os.crons.start.handler(async ({ input, context }) => {
+	return serializeCron(context.manager.startCronByTarget(input.target));
+});
+const stopCron = os.crons.stop.handler(async ({ input, context }) => {
+	return serializeCron(await context.manager.stopCronByTarget(input.target));
+});
+const getTask = os.tasks.get.handler(async ({ input, context }) => {
+	const task = context.manager.getTaskByTarget(input.target);
+	if (!task) throw new Error(`Task not found: ${input.target}`);
+	return task;
+});
+const listTasks = os.tasks.list.handler(async ({ context }) => {
+	const taskList = context.manager.getTaskList();
+	if (!taskList) return [];
+	return taskList.tasks.map((t) => ({
+		id: t.id,
+		state: t.state,
+		processNames: t.processes.map((p) => p.name)
+	}));
+});
+const addTask = os.tasks.add.handler(async ({ input, context }) => {
+	return context.manager.addTask(input.name, input.definition);
+});
+const removeTask = os.tasks.remove.handler(async ({ input, context }) => {
+	return context.manager.removeTaskByTarget(input.target);
+});
+const router = os.router({
+	manager: { status: managerStatus },
+	processes: {
+		add: addProcess,
+		get: getProcess,
+		list: listProcesses,
+		start: startProcess,
+		stop: stopProcess,
+		restart: restartProcess,
+		reload: reloadProcess,
+		remove: removeProcess
+	},
+	crons: {
+		get: getCron,
+		list: listCrons,
+		trigger: triggerCron,
+		start: startCron,
+		stop: stopCron
+	},
+	tasks: {
+		get: getTask,
+		list: listTasks,
+		add: addTask,
+		remove: removeTask
+	}
+});
+
+//#endregion
+//#region src/manager.ts
+const HttpServerConfigSchema = v.object({
+	host: v.optional(v.string()),
+	port: v.optional(v.number()),
+	authToken: v.optional(v.string())
+});
+const CronProcessEntrySchema = v.object({
+	name: v.string(),
+	definition: ProcessDefinitionSchema,
+	options: CronProcessOptionsSchema,
+	envFile: v.optional(v.string())
+});
+const EnvReloadDelaySchema = v.union([
+	v.number(),
+	v.boolean(),
+	v.literal("immediately")
+]);
+const RestartingProcessEntrySchema = v.object({
+	name: v.string(),
+	definition: ProcessDefinitionSchema,
+	options: v.optional(RestartingProcessOptionsSchema),
+	envFile: v.optional(v.string()),
+	envReloadDelay: v.optional(EnvReloadDelaySchema)
+});
+const TaskEntrySchema = v.object({
+	name: v.string(),
+	definition: ProcessDefinitionSchema,
+	envFile: v.optional(v.string())
+});
+const ManagerConfigSchema = v.object({
+	http: v.optional(HttpServerConfigSchema),
+	cwd: v.optional(v.string()),
+	logDir: v.optional(v.string()),
+	env: v.optional(v.record(v.string(), v.string())),
+	envFiles: v.optional(v.record(v.string(), v.string())),
+	tasks: v.optional(v.array(TaskEntrySchema)),
+	crons: v.optional(v.array(CronProcessEntrySchema)),
+	processes: v.optional(v.array(RestartingProcessEntrySchema))
+});
+const DEFAULT_RESTART_OPTIONS = { restartPolicy: "always" };
+const SHUTDOWN_TIMEOUT_MS = 15e3;
+const SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM"];
+const SHUTDOWN_EXIT_CODE = 0;
+var Manager = class {
+	config;
+	logger;
+	envManager;
+	envFileKeyByProcess = /* @__PURE__ */ new Map();
+	_state = "idle";
+	taskList = null;
+	cronProcesses = /* @__PURE__ */ new Map();
+	restartingProcesses = /* @__PURE__ */ new Map();
+	logDir;
+	processEnvReloadConfig = /* @__PURE__ */ new Map();
+	envReloadTimers = /* @__PURE__ */ new Map();
+	envChangeUnsubscribe = null;
+	signalHandlers = /* @__PURE__ */ new Map();
+	shutdownPromise = null;
+	isShuttingDown = false;
+	constructor(config, logger) {
+		this.config = config;
+		this.logger = logger;
+		this.logDir = config.logDir ?? join(cwd(), "logs");
+		this.ensureLogDirs();
+		this.envManager = new EnvManager({
+			cwd: config.cwd,
+			files: config.envFiles,
+			watch: true
+		});
+		this.envChangeUnsubscribe = this.envManager.onChange((changedKeys) => {
+			this.handleEnvChange(changedKeys);
+		});
+		this.registerShutdownHandlers();
+	}
+	/**
+	* Merge global env with process-specific env and apply cwd inheritance
+	* Merge order: .env (global), config.env (global), .env.<processName>, processEnvFile, definition.env
+	*/
+	applyDefaults(processName, definition, envFile) {
+		const envFromFiles = this.envManager.getEnvVars(processName);
+		let envFromCustomFile = {};
+		if (envFile) {
+			let key = this.envFileKeyByProcess.get(processName);
+			if (!key) {
+				key = `custom:${processName}`;
+				this.envFileKeyByProcess.set(processName, key);
+				this.envManager.registerFile(key, envFile);
+			}
+			envFromCustomFile = this.envManager.getEnvForKey(key);
+		}
+		return {
+			...definition,
+			cwd: definition.cwd ?? this.config.cwd,
+			env: {
+				...envFromFiles,
+				...this.config.env,
+				...envFromCustomFile,
+				...definition.env
+			}
+		};
+	}
+	processLogFile(name) {
+		return join(this.logDir, "process", `${name}.log`);
+	}
+	taskLogFile(name) {
+		return join(this.logDir, "tasks", `${name}.log`);
+	}
+	cronLogFile(name) {
+		return join(this.logDir, "cron", `${name}.log`);
+	}
+	ensureLogDirs() {
+		mkdirSync(this.logDir, { recursive: true });
+		mkdirSync(join(this.logDir, "process"), { recursive: true });
+		mkdirSync(join(this.logDir, "tasks"), { recursive: true });
+		mkdirSync(join(this.logDir, "cron"), { recursive: true });
+	}
+	/**
+	* Handle env file changes
+	*/
+	handleEnvChange(changedKeys) {
+		if (this._state !== "running") return;
+		this.logger.info(`Env files changed for keys: ${changedKeys.join(", ")}`);
+		const affectedProcesses = /* @__PURE__ */ new Set();
+		for (const key of changedKeys) if (key === "global") for (const processName of this.restartingProcesses.keys()) affectedProcesses.add(processName);
+		else {
+			if (this.restartingProcesses.has(key)) affectedProcesses.add(key);
+			for (const [processName, customKey] of this.envFileKeyByProcess.entries()) if (customKey === key && this.restartingProcesses.has(processName)) affectedProcesses.add(processName);
+		}
+		for (const processName of affectedProcesses) {
+			const reloadDelay = this.processEnvReloadConfig.get(processName);
+			if (reloadDelay === false) continue;
+			this.scheduleProcessReload(processName, reloadDelay);
+		}
+	}
+	/**
+	* Schedule a process reload with debouncing
+	*/
+	scheduleProcessReload(processName, reloadDelay) {
+		const existingTimer = this.envReloadTimers.get(processName);
+		if (existingTimer) clearTimeout(existingTimer);
+		let delayMs;
+		if (reloadDelay === false) return;
+		else if (reloadDelay === true || reloadDelay === "immediately") delayMs = 0;
+		else if (typeof reloadDelay === "number") delayMs = reloadDelay;
+		else delayMs = 5e3;
+		this.logger.info(`Scheduling reload for process "${processName}" in ${delayMs}ms`);
+		const timer = setTimeout(async () => {
+			await this.reloadProcessEnv(processName);
+			this.envReloadTimers.delete(processName);
+		}, delayMs);
+		this.envReloadTimers.set(processName, timer);
+	}
+	/**
+	* Reload a process with updated env vars
+	*/
+	async reloadProcessEnv(processName) {
+		const proc = this.restartingProcesses.get(processName);
+		if (!proc) {
+			this.logger.warn(`Process "${processName}" not found for env reload`);
+			return;
+		}
+		this.logger.info(`Reloading process "${processName}" due to env change`);
+		const processConfig = this.config.processes?.find((p) => p.name === processName);
+		if (!processConfig) {
+			this.logger.warn(`Process config for "${processName}" not found`);
+			return;
+		}
+		const updatedDefinition = this.applyDefaults(processName, processConfig.definition, processConfig.envFile);
+		await proc.reload(updatedDefinition, true);
+	}
+	get state() {
+		return this._state;
+	}
+	/**
+	* Get all cron processes (read-only access)
+	*/
+	getCronProcesses() {
+		return this.cronProcesses;
+	}
+	/**
+	* Get a specific cron process by name
+	*/
+	getCronProcess(name) {
+		return this.cronProcesses.get(name);
+	}
+	/**
+	* Get all restarting processes (read-only access)
+	*/
+	getRestartingProcesses() {
+		return this.restartingProcesses;
+	}
+	/**
+	* Get a specific restarting process by name
+	*/
+	getRestartingProcess(name) {
+		return this.restartingProcesses.get(name);
+	}
+	/**
+	* Get the task list (read-only access)
+	*/
+	getTaskList() {
+		return this.taskList;
+	}
+	/**
+	* Get a restarting process by name or index
+	*/
+	getProcessByTarget(target) {
+		if (typeof target === "string") return this.restartingProcesses.get(target);
+		return Array.from(this.restartingProcesses.values())[target];
+	}
+	/**
+	* Get a cron process by name or index
+	*/
+	getCronByTarget(target) {
+		if (typeof target === "string") return this.cronProcesses.get(target);
+		return Array.from(this.cronProcesses.values())[target];
+	}
+	/**
+	* Get a task by id or index
+	*/
+	getTaskByTarget(target) {
+		if (!this.taskList) return void 0;
+		const tasks = this.taskList.tasks;
+		if (typeof target === "string") {
+			const task = tasks.find((t) => t.id === target);
+			if (!task) return void 0;
+			return {
+				id: task.id,
+				state: task.state,
+				processNames: task.processes.map((p) => p.name)
+			};
+		}
+		const task = tasks[target];
+		if (!task) return void 0;
+		return {
+			id: task.id,
+			state: task.state,
+			processNames: task.processes.map((p) => p.name)
+		};
+	}
+	/**
+	* Start a restarting process by target
+	*/
+	startProcessByTarget(target) {
+		const proc = this.getProcessByTarget(target);
+		if (!proc) throw new Error(`Process not found: ${target}`);
+		proc.start();
+		return proc;
+	}
+	/**
+	* Stop a restarting process by target
+	*/
+	async stopProcessByTarget(target, timeout) {
+		const proc = this.getProcessByTarget(target);
+		if (!proc) throw new Error(`Process not found: ${target}`);
+		await proc.stop(timeout);
+		return proc;
+	}
+	/**
+	* Restart a restarting process by target
+	*/
+	async restartProcessByTarget(target, force = false) {
+		const proc = this.getProcessByTarget(target);
+		if (!proc) throw new Error(`Process not found: ${target}`);
+		await proc.restart(force);
+		return proc;
+	}
+	/**
+	* Reload a restarting process with new definition
+	*/
+	async reloadProcessByTarget(target, newDefinition, options) {
+		const proc = this.getProcessByTarget(target);
+		if (!proc) throw new Error(`Process not found: ${target}`);
+		const definitionWithDefaults = this.applyDefaults(proc.name, newDefinition);
+		if (options?.updateOptions) proc.updateOptions(options.updateOptions);
+		await proc.reload(definitionWithDefaults, options?.restartImmediately ?? true);
+		this.logger.info(`Reloaded process: ${proc.name}`);
+		return proc;
+	}
+	/**
+	* Remove a restarting process by target
+	*/
+	async removeProcessByTarget(target, timeout) {
+		const proc = this.getProcessByTarget(target);
+		if (!proc) throw new Error(`Process not found: ${target}`);
+		await proc.stop(timeout);
+		this.restartingProcesses.delete(proc.name);
+		this.logger.info(`Removed process: ${proc.name}`);
+	}
+	/**
+	* Add a task to the task list
+	* Creates the task list if it doesn't exist and starts it
+	*/
+	addTask(name, definition) {
+		if (!this.taskList) this.taskList = new TaskList("runtime", this.logger.child("tasks", { logFile: this.taskLogFile("tasks") }), void 0, (processName) => {
+			return this.taskLogFile(processName);
+		});
+		const namedProcess = {
+			name,
+			process: this.applyDefaults(name, definition)
+		};
+		const id = this.taskList.addTask(namedProcess);
+		if (this.taskList.state === "idle") this.taskList.start();
+		return {
+			id,
+			state: "pending",
+			processNames: [name]
+		};
+	}
+	removeTaskByTarget(target) {
+		if (!this.taskList) throw new Error(`Task list not initialized`);
+		const removed = this.taskList.removeTaskByTarget(target);
+		return {
+			id: removed.id,
+			state: removed.state,
+			processNames: removed.processes.map((p) => p.name)
+		};
+	}
+	/**
+	* Add a restarting process at runtime
+	*/
+	addProcess(name, definition, options, envReloadDelay) {
+		if (this.restartingProcesses.has(name)) throw new Error(`Process "${name}" already exists`);
+		const processLogger = this.logger.child(name, { logFile: this.processLogFile(name) });
+		const restartingProcess = new RestartingProcess(name, this.applyDefaults(name, definition), options ?? DEFAULT_RESTART_OPTIONS, processLogger);
+		this.restartingProcesses.set(name, restartingProcess);
+		restartingProcess.start();
+		this.processEnvReloadConfig.set(name, envReloadDelay ?? 5e3);
+		this.logger.info(`Added and started restarting process: ${name}`);
+		return restartingProcess;
+	}
+	/**
+	* Trigger a cron process by target
+	*/
+	async triggerCronByTarget(target) {
+		const cron = this.getCronByTarget(target);
+		if (!cron) throw new Error(`Cron not found: ${target}`);
+		await cron.trigger();
+		return cron;
+	}
+	/**
+	* Start a cron process by target
+	*/
+	startCronByTarget(target) {
+		const cron = this.getCronByTarget(target);
+		if (!cron) throw new Error(`Cron not found: ${target}`);
+		cron.start();
+		return cron;
+	}
+	/**
+	* Stop a cron process by target
+	*/
+	async stopCronByTarget(target, timeout) {
+		const cron = this.getCronByTarget(target);
+		if (!cron) throw new Error(`Cron not found: ${target}`);
+		await cron.stop(timeout);
+		return cron;
+	}
+	/**
+	* Start the manager:
+	* 1. Run task list (if configured) and wait for completion
+	* 2. Create and start all cron/restarting processes
+	*/
+	async start() {
+		if (this._state !== "idle" && this._state !== "stopped") throw new Error(`Manager is already ${this._state}`);
+		this.logger.info(`Starting manager`);
+		if (this.config.tasks && this.config.tasks.length > 0) {
+			this._state = "initializing";
+			this.logger.info(`Running initialization tasks`);
+			this.taskList = new TaskList("init", this.logger.child("tasks"), this.config.tasks.map((task) => ({
+				name: task.name,
+				process: this.applyDefaults(task.name, task.definition, task.envFile)
+			})), (processName) => {
+				return this.taskLogFile(processName);
+			});
+			this.taskList.start();
+			await this.taskList.waitUntilIdle();
+			const failedTasks = this.taskList.tasks.filter((t) => t.state === "failed");
+			if (failedTasks.length > 0) {
+				this._state = "stopped";
+				const failedNames = failedTasks.map((t) => t.id).join(", ");
+				throw new Error(`Initialization failed: tasks [${failedNames}] failed`);
+			}
+			this.logger.info(`Initialization tasks completed`);
+		}
+		if (this.config.crons) for (const entry of this.config.crons) {
+			const processLogger = this.logger.child(entry.name, { logFile: this.cronLogFile(entry.name) });
+			const cronProcess = new CronProcess(entry.name, this.applyDefaults(entry.name, entry.definition, entry.envFile), entry.options, processLogger);
+			this.cronProcesses.set(entry.name, cronProcess);
+			cronProcess.start();
+			this.logger.info(`Started cron process: ${entry.name}`);
+		}
+		if (this.config.processes) for (const entry of this.config.processes) {
+			const processLogger = this.logger.child(entry.name, { logFile: this.processLogFile(entry.name) });
+			const restartingProcess = new RestartingProcess(entry.name, this.applyDefaults(entry.name, entry.definition, entry.envFile), entry.options ?? DEFAULT_RESTART_OPTIONS, processLogger);
+			this.restartingProcesses.set(entry.name, restartingProcess);
+			restartingProcess.start();
+			this.processEnvReloadConfig.set(entry.name, entry.envReloadDelay ?? 5e3);
+			this.logger.info(`Started restarting process: ${entry.name}`);
+		}
+		this._state = "running";
+		this.logger.info(`Manager started with ${this.cronProcesses.size} cron process(es) and ${this.restartingProcesses.size} restarting process(es)`);
+	}
+	/**
+	* Stop all managed processes
+	*/
+	async stop(timeout) {
+		if (this._state === "idle" || this._state === "stopped") {
+			this._state = "stopped";
+			this.unregisterShutdownHandlers();
+			return;
+		}
+		this._state = "stopping";
+		this.logger.info(`Stopping manager`);
+		for (const timer of this.envReloadTimers.values()) clearTimeout(timer);
+		this.envReloadTimers.clear();
+		if (this.envChangeUnsubscribe) {
+			this.envChangeUnsubscribe();
+			this.envChangeUnsubscribe = null;
+		}
+		this.envManager.dispose();
+		if (this.taskList) await this.taskList.stop(timeout);
+		const cronStopPromises = Array.from(this.cronProcesses.values()).map((p) => p.stop(timeout));
+		const restartingStopPromises = Array.from(this.restartingProcesses.values()).map((p) => p.stop(timeout));
+		await Promise.all([...cronStopPromises, ...restartingStopPromises]);
+		this._state = "stopped";
+		this.logger.info(`Manager stopped`);
+		this.unregisterShutdownHandlers();
+	}
+	/**
+	* Register signal handlers for graceful shutdown
+	* Called automatically by constructor
+	*/
+	registerShutdownHandlers() {
+		if (this.signalHandlers.size > 0) {
+			this.logger.warn(`Shutdown handlers already registered`);
+			return;
+		}
+		for (const signal of SHUTDOWN_SIGNALS) {
+			const handler = () => this.handleSignal(signal);
+			this.signalHandlers.set(signal, handler);
+			process.on(signal, handler);
+			this.logger.debug(`Registered handler for ${signal}`);
+		}
+		this.logger.info(`Shutdown handlers registered for signals: ${SHUTDOWN_SIGNALS.join(", ")}`);
+	}
+	/**
+	* Unregister signal handlers for graceful shutdown
+	*/
+	unregisterShutdownHandlers() {
+		if (this.signalHandlers.size === 0) return;
+		for (const [signal, handler] of this.signalHandlers.entries()) {
+			process.off(signal, handler);
+			this.logger.debug(`Unregistered handler for ${signal}`);
+		}
+		this.signalHandlers.clear();
+	}
+	/**
+	* Wait for shutdown to complete (useful for keeping process alive)
+	* Resolves when the manager has fully stopped
+	*/
+	async waitForShutdown() {
+		if (this._state === "stopped") return;
+		if (this.shutdownPromise) {
+			await this.shutdownPromise;
+			return;
+		}
+		return new Promise((resolve) => {
+			const checkInterval = setInterval(() => {
+				if (this._state === "stopped") {
+					clearInterval(checkInterval);
+					resolve();
+				}
+			}, 100);
+		});
+	}
+	/**
+	* Trigger graceful shutdown programmatically
+	*/
+	async shutdown() {
+		if (this.isShuttingDown) {
+			this.logger.warn(`Shutdown already in progress`);
+			if (this.shutdownPromise) await this.shutdownPromise;
+			return;
+		}
+		this.isShuttingDown = true;
+		this.logger.info(`Initiating graceful shutdown (timeout: ${SHUTDOWN_TIMEOUT_MS}ms)`);
+		this.shutdownPromise = this.performShutdown();
+		await this.shutdownPromise;
+	}
+	handleSignal(signal) {
+		this.logger.info(`Received ${signal}, initiating graceful shutdown...`);
+		if (this.isShuttingDown) {
+			this.logger.warn(`Shutdown already in progress, ignoring ${signal}`);
+			return;
+		}
+		this.isShuttingDown = true;
+		this.shutdownPromise = this.performShutdown();
+		this.shutdownPromise.then(() => {
+			this.logger.info(`Exiting with code ${SHUTDOWN_EXIT_CODE}`);
+			process.exit(SHUTDOWN_EXIT_CODE);
+		}).catch((err) => {
+			this.logger.error(`Shutdown error:`, err);
+			process.exit(1);
+		});
+	}
+	async performShutdown() {
+		const timeoutPromise = new Promise((_, reject) => {
+			setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms`));
+			}, SHUTDOWN_TIMEOUT_MS);
+		});
+		try {
+			await Promise.race([this.stop(SHUTDOWN_TIMEOUT_MS), timeoutPromise]);
+			this.logger.info(`Graceful shutdown completed`);
+		} catch (err) {
+			this.logger.error(`Shutdown error:`, err);
+			this._state = "stopped";
+			throw err;
+		} finally {
+			this.isShuttingDown = false;
+			this.shutdownPromise = null;
+		}
+	}
+};
+
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("pidnap").description("Process manager with init system capabilities").version("0.0.0-dev.1");
+program.command("init").description("Initialize and run the process manager with config file").option("-c, --config <path>", "Path to config file", "pidnap.config.ts").action(async (options) => {
+	const initLogger = logger({ name: "pidnap" });
+	try {
+		const configUrl = pathToFileURL(resolve(process.cwd(), options.config)).href;
+		const configModule = await tsImport(configUrl, { parentURL: import.meta.url });
+		const rawConfig = configModule.default.default || configModule.default || configModule.config || {};
+		const config = v.parse(ManagerConfigSchema, rawConfig);
+		const host = config.http?.host ?? "localhost";
+		const port = config.http?.port ?? 3e3;
+		const authToken = config.http?.authToken;
+		const managerLogger = logger({
+			name: "pidnap",
+			logFile: resolve(config.logDir ?? resolve(process.cwd(), "logs"), "pidnap.log")
+		});
+		const manager = new Manager(config, managerLogger);
+		const handler = new RPCHandler(router, { interceptors: [onError((error) => {
+			managerLogger.error(error);
+		})] });
+		const server = createServer(async (req, res) => {
+			if (authToken) {
+				if (req.headers["authorization"]?.replace("Bearer ", "") !== authToken) {
+					res.statusCode = 401;
+					res.end("Unauthorized");
+					return;
+				}
+			}
+			const { matched } = await handler.handle(req, res, {
+				prefix: "/rpc",
+				context: { manager }
+			});
+			if (matched) return;
+			res.statusCode = 404;
+			res.end("Not found");
+		});
+		server.listen(port, host, async () => {
+			managerLogger.info(`pidnap RPC server running on http://${host}:${port}`);
+			if (authToken) managerLogger.info("Auth token required for API access");
+			try {
+				await manager.start();
+			} catch (err) {
+				managerLogger.error("Failed to start manager:", err);
+				server.close();
+				process.exit(1);
+			}
+		});
+		await manager.waitForShutdown();
+		server.close();
+	} catch (error) {
+		initLogger.error("Failed to start pidnap:", error);
+		process.exit(1);
+	}
+});
+program.command("status").description("Show manager status").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const status = await createClient(options.url).manager.status();
+		const table = new Table({ head: [
+			"State",
+			"Processes",
+			"Crons",
+			"Tasks"
+		] });
+		table.push([
+			status.state,
+			status.processCount,
+			status.cronCount,
+			status.taskCount
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to fetch status:", error);
+		process.exit(1);
+	}
+});
+const processes = program.command("processes").description("Manage restarting processes");
+processes.command("list").description("List restarting processes").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const processes = await createClient(options.url).processes.list();
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		for (const proc of processes) table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to list processes:", error);
+		process.exit(1);
+	}
+});
+processes.command("get").description("Get a restarting process by name or index").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const proc = await createClient(options.url).processes.get({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to get process:", error);
+		process.exit(1);
+	}
+});
+processes.command("add").description("Add a restarting process").requiredOption("-n, --name <name>", "Process name").requiredOption("-d, --definition <json>", "Process definition JSON").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const client = createClient(options.url);
+		const definition = parseDefinition(options.definition);
+		const proc = await client.processes.add({
+			name: options.name,
+			definition
+		});
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to add process:", error);
+		process.exit(1);
+	}
+});
+processes.command("start").description("Start a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const proc = await createClient(options.url).processes.start({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to start process:", error);
+		process.exit(1);
+	}
+});
+processes.command("stop").description("Stop a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const proc = await createClient(options.url).processes.stop({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to stop process:", error);
+		process.exit(1);
+	}
+});
+processes.command("restart").description("Restart a restarting process").argument("<target>", "Process name or index").option("-f, --force", "Force restart").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const proc = await createClient(options.url).processes.restart({
+			target: parseTarget(target),
+			force: options.force
+		});
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Restarts"
+		] });
+		table.push([
+			proc.name,
+			proc.state,
+			proc.restarts
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to restart process:", error);
+		process.exit(1);
+	}
+});
+processes.command("remove").description("Remove a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		await createClient(options.url).processes.remove({ target: parseTarget(target) });
+		console.log("Process removed");
+	} catch (error) {
+		console.error("Failed to remove process:", error);
+		process.exit(1);
+	}
+});
+const crons = program.command("crons").description("Manage cron processes");
+crons.command("list").description("List cron processes").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const crons = await createClient(options.url).crons.list();
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Runs",
+			"Fails",
+			"Next Run"
+		] });
+		for (const cron of crons) table.push([
+			cron.name,
+			cron.state,
+			cron.runCount,
+			cron.failCount,
+			cron.nextRun ?? "-"
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to list crons:", error);
+		process.exit(1);
+	}
+});
+crons.command("get").description("Get a cron process by name or index").argument("<target>", "Cron name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const cron = await createClient(options.url).crons.get({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Runs",
+			"Fails",
+			"Next Run"
+		] });
+		table.push([
+			cron.name,
+			cron.state,
+			cron.runCount,
+			cron.failCount,
+			cron.nextRun ?? "-"
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to get cron:", error);
+		process.exit(1);
+	}
+});
+crons.command("trigger").description("Trigger a cron process").argument("<target>", "Cron name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const cron = await createClient(options.url).crons.trigger({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Runs",
+			"Fails",
+			"Next Run"
+		] });
+		table.push([
+			cron.name,
+			cron.state,
+			cron.runCount,
+			cron.failCount,
+			cron.nextRun ?? "-"
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to trigger cron:", error);
+		process.exit(1);
+	}
+});
+crons.command("start").description("Start a cron process").argument("<target>", "Cron name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const cron = await createClient(options.url).crons.start({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Runs",
+			"Fails",
+			"Next Run"
+		] });
+		table.push([
+			cron.name,
+			cron.state,
+			cron.runCount,
+			cron.failCount,
+			cron.nextRun ?? "-"
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to start cron:", error);
+		process.exit(1);
+	}
+});
+crons.command("stop").description("Stop a cron process").argument("<target>", "Cron name or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const cron = await createClient(options.url).crons.stop({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Name",
+			"State",
+			"Runs",
+			"Fails",
+			"Next Run"
+		] });
+		table.push([
+			cron.name,
+			cron.state,
+			cron.runCount,
+			cron.failCount,
+			cron.nextRun ?? "-"
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to stop cron:", error);
+		process.exit(1);
+	}
+});
+const tasks = program.command("tasks").description("Manage tasks");
+tasks.command("list").description("List tasks").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const tasks = await createClient(options.url).tasks.list();
+		const table = new Table({ head: [
+			"Id",
+			"State",
+			"Processes"
+		] });
+		for (const task of tasks) table.push([
+			task.id,
+			task.state,
+			task.processNames.join(", ")
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to list tasks:", error);
+		process.exit(1);
+	}
+});
+tasks.command("get").description("Get a task by id or index").argument("<target>", "Task id or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const task = await createClient(options.url).tasks.get({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Id",
+			"State",
+			"Processes"
+		] });
+		table.push([
+			task.id,
+			task.state,
+			task.processNames.join(", ")
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to get task:", error);
+		process.exit(1);
+	}
+});
+tasks.command("add").description("Add a task").requiredOption("-n, --name <name>", "Task name").requiredOption("-d, --definition <json>", "Process definition JSON").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+	try {
+		const client = createClient(options.url);
+		const definition = parseDefinition(options.definition);
+		const task = await client.tasks.add({
+			name: options.name,
+			definition
+		});
+		const table = new Table({ head: [
+			"Id",
+			"State",
+			"Processes"
+		] });
+		table.push([
+			task.id,
+			task.state,
+			task.processNames.join(", ")
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to add task:", error);
+		process.exit(1);
+	}
+});
+tasks.command("remove").description("Remove a task by id or index").argument("<target>", "Task id or index").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (target, options) => {
+	try {
+		const task = await createClient(options.url).tasks.remove({ target: parseTarget(target) });
+		const table = new Table({ head: [
+			"Id",
+			"State",
+			"Processes"
+		] });
+		table.push([
+			task.id,
+			task.state,
+			task.processNames.join(", ")
+		]);
+		console.log(table.toString());
+	} catch (error) {
+		console.error("Failed to remove task:", error);
+		process.exit(1);
+	}
+});
+const TargetSchema = v.union([v.string(), v.number()]);
+function parseTarget(value) {
+	const asNumber = Number(value);
+	return v.parse(TargetSchema, Number.isNaN(asNumber) ? value : asNumber);
+}
+function parseDefinition(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return v.parse(ProcessDefinitionSchema, parsed);
+	} catch (error) {
+		console.error("Invalid --definition JSON. Expected a ProcessDefinition.");
+		throw error;
+	}
+}
+program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map