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

package/dist/cli.mjs

@@ -1,24 +1,22 @@
 #!/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, y as treeKill } from "./logger-BIJzGqk3.mjs";
+import { _ as ProcessDefinition, a as TaskStateSchema, c as CronProcessState, h as RestartingProcessState, i as TaskList, m as RestartingProcessOptions, n as EnvManager, o as CronProcess, p as RestartingProcess, s as CronProcessOptions, t as logger } from "./logger-BU2RmetS.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 { implement, onError, os } from "@orpc/server";
 import * as v from "valibot";
 import { oc } from "@orpc/contract";
-import { exec } from "node:child_process";
 import { cwd } from "node:process";
 import { mkdirSync } from "node:fs";
-import { promisify } from "node:util";
-import { tsImport } from "tsx/esm/api";
+import { format } from "node:util";
 import Table from "cli-table3";
+import { createCli } from "trpc-cli";
 
 //#region src/api/contract.ts
 const oc$1 = oc.$input(v.void());
-const ResourceTarget = v.union([v.string(), v.number()]);
+const ResourceTarget$1 = v.union([v.string(), v.number()]);
 const ManagerStateSchema = v.picklist([
 	"idle",
 	"initializing",
@@ -34,12 +32,12 @@ const ManagerStatusSchema = v.object({
 });
 const RestartingProcessInfoSchema = v.object({
 	name: v.string(),
-	state: RestartingProcessStateSchema,
+	state: RestartingProcessState,
 	restarts: v.number()
 });
 const CronProcessInfoSchema = v.object({
 	name: v.string(),
-	state: CronProcessStateSchema,
+	state: CronProcessState,
 	runCount: v.number(),
 	failCount: v.number(),
 	nextRun: v.nullable(v.string())
@@ -50,52 +48,52 @@ const TaskEntryInfoSchema = v.object({
 	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),
+const processes = {
+	get: oc$1.input(v.object({ target: ResourceTarget$1 })).output(RestartingProcessInfoSchema),
 	list: oc$1.output(v.array(RestartingProcessInfoSchema)),
 	add: oc$1.input(v.object({
 		name: v.string(),
-		definition: ProcessDefinitionSchema
+		definition: ProcessDefinition
 	})).output(RestartingProcessInfoSchema),
-	start: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
-	stop: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
+	start: oc$1.input(v.object({ target: ResourceTarget$1 })).output(RestartingProcessInfoSchema),
+	stop: oc$1.input(v.object({ target: ResourceTarget$1 })).output(RestartingProcessInfoSchema),
 	restart: oc$1.input(v.object({
-		target: ResourceTarget,
+		target: ResourceTarget$1,
 		force: v.optional(v.boolean())
 	})).output(RestartingProcessInfoSchema),
 	reload: oc$1.input(v.object({
-		target: ResourceTarget,
-		definition: ProcessDefinitionSchema,
+		target: ResourceTarget$1,
+		definition: ProcessDefinition,
 		restartImmediately: v.optional(v.boolean())
 	})).output(RestartingProcessInfoSchema),
-	remove: oc$1.input(v.object({ target: ResourceTarget })).output(v.object({ success: v.boolean() }))
+	remove: oc$1.input(v.object({ target: ResourceTarget$1 })).output(v.object({ success: v.boolean() }))
 };
-const tasks$1 = {
-	get: oc$1.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema),
+const tasks = {
+	get: oc$1.input(v.object({ target: ResourceTarget$1 })).output(TaskEntryInfoSchema),
 	list: oc$1.output(v.array(TaskEntryInfoSchema)),
 	add: oc$1.input(v.object({
 		name: v.string(),
-		definition: ProcessDefinitionSchema
+		definition: ProcessDefinition
 	})).output(TaskEntryInfoSchema),
-	remove: oc$1.input(v.object({ target: ResourceTarget })).output(TaskEntryInfoSchema)
+	remove: oc$1.input(v.object({ target: ResourceTarget$1 })).output(TaskEntryInfoSchema)
 };
-const crons$1 = {
-	get: oc$1.input(v.object({ target: ResourceTarget })).output(CronProcessInfoSchema),
+const crons = {
+	get: oc$1.input(v.object({ target: ResourceTarget$1 })).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)
+	trigger: oc$1.input(v.object({ target: ResourceTarget$1 })).output(CronProcessInfoSchema),
+	start: oc$1.input(v.object({ target: ResourceTarget$1 })).output(CronProcessInfoSchema),
+	stop: oc$1.input(v.object({ target: ResourceTarget$1 })).output(CronProcessInfoSchema)
 };
 const api = {
 	manager,
-	processes: processes$1,
-	tasks: tasks$1,
-	crons: crons$1
+	processes,
+	tasks,
+	crons
 };
 
 //#endregion
 //#region src/api/server.ts
-const os = implement(api).$context();
+const os$2 = implement(api).$context();
 function serializeProcess(proc) {
 	return {
 		name: proc.name,
@@ -112,7 +110,7 @@ function serializeCron(cron) {
 		nextRun: cron.nextRun?.toISOString() ?? null
 	};
 }
-const managerStatus = os.manager.status.handler(async ({ context }) => {
+const managerStatus = os$2.manager.status.handler(async ({ context }) => {
 	const manager = context.manager;
 	const taskList = manager.getTaskList();
 	return {
@@ -122,56 +120,56 @@ const managerStatus = os.manager.status.handler(async ({ context }) => {
 		taskCount: taskList?.tasks.length ?? 0
 	};
 });
-const getProcess = os.processes.get.handler(async ({ input, context }) => {
+const getProcess = os$2.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 }) => {
+const listProcesses = os$2.processes.list.handler(async ({ context }) => {
 	return Array.from(context.manager.getRestartingProcesses().values()).map(serializeProcess);
 });
-const addProcess = os.processes.add.handler(async ({ input, context }) => {
+const addProcess = os$2.processes.add.handler(async ({ input, context }) => {
 	return serializeProcess(await context.manager.addProcess(input.name, input.definition));
 });
-const startProcess = os.processes.start.handler(async ({ input, context }) => {
+const startProcess = os$2.processes.start.handler(async ({ input, context }) => {
 	return serializeProcess(await context.manager.startProcessByTarget(input.target));
 });
-const stopProcess = os.processes.stop.handler(async ({ input, context }) => {
+const stopProcess = os$2.processes.stop.handler(async ({ input, context }) => {
 	return serializeProcess(await context.manager.stopProcessByTarget(input.target));
 });
-const restartProcess = os.processes.restart.handler(async ({ input, context }) => {
+const restartProcess = os$2.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 }) => {
+const reloadProcess = os$2.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 }) => {
+const removeProcess = os$2.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 getCron = os$2.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 }) => {
+const listCrons = os$2.crons.list.handler(async ({ context }) => {
 	return Array.from(context.manager.getCronProcesses().values()).map(serializeCron);
 });
-const triggerCron = os.crons.trigger.handler(async ({ input, context }) => {
+const triggerCron = os$2.crons.trigger.handler(async ({ input, context }) => {
 	return serializeCron(await context.manager.triggerCronByTarget(input.target));
 });
-const startCron = os.crons.start.handler(async ({ input, context }) => {
+const startCron = os$2.crons.start.handler(async ({ input, context }) => {
 	return serializeCron(context.manager.startCronByTarget(input.target));
 });
-const stopCron = os.crons.stop.handler(async ({ input, context }) => {
+const stopCron = os$2.crons.stop.handler(async ({ input, context }) => {
 	return serializeCron(await context.manager.stopCronByTarget(input.target));
 });
-const getTask = os.tasks.get.handler(async ({ input, context }) => {
+const getTask = os$2.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 listTasks = os$2.tasks.list.handler(async ({ context }) => {
 	const taskList = context.manager.getTaskList();
 	if (!taskList) return [];
 	return taskList.tasks.map((t) => ({
@@ -180,13 +178,13 @@ const listTasks = os.tasks.list.handler(async ({ context }) => {
 		processNames: t.processes.map((p) => p.name)
 	}));
 });
-const addTask = os.tasks.add.handler(async ({ input, context }) => {
+const addTask = os$2.tasks.add.handler(async ({ input, context }) => {
 	return context.manager.addTask(input.name, input.definition);
 });
-const removeTask = os.tasks.remove.handler(async ({ input, context }) => {
+const removeTask = os$2.tasks.remove.handler(async ({ input, context }) => {
 	return context.manager.removeTaskByTarget(input.target);
 });
-const router = os.router({
+const router = os$2.router({
 	manager: { status: managerStatus },
 	processes: {
 		add: addProcess,
@@ -213,76 +211,52 @@ const router = os.router({
 	}
 });
 
-//#endregion
-//#region src/port-utils.ts
-const execAsync = promisify(exec);
-/**
-* Kill any process listening on the specified port, including all descendants.
-*/
-async function killProcessOnPort(port) {
-	try {
-		const { stdout } = await execAsync(`lsof -ti tcp:${port}`);
-		const pids = stdout.trim().split("\n").filter(Boolean).map((p) => parseInt(p, 10)).filter((p) => !isNaN(p));
-		if (pids.length === 0) return false;
-		for (const pid of pids) try {
-			await treeKill(pid, "SIGKILL");
-		} catch {}
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 //#endregion
 //#region src/manager.ts
-const HttpServerConfigSchema = v.object({
+const HttpServerConfig = v.object({
 	host: v.optional(v.string()),
 	port: v.optional(v.number()),
 	authToken: v.optional(v.string())
 });
-const CronProcessEntrySchema = v.object({
+const CronProcessEntry = v.object({
 	name: v.string(),
-	definition: ProcessDefinitionSchema,
-	options: CronProcessOptionsSchema,
+	definition: ProcessDefinition,
+	options: CronProcessOptions,
 	envFile: v.optional(v.string())
 });
-const EnvReloadDelaySchema = v.union([
+const EnvReloadDelay = v.union([
 	v.number(),
 	v.boolean(),
 	v.literal("immediately")
 ]);
-const RestartingProcessEntrySchema = v.object({
+const RestartingProcessEntry = v.object({
 	name: v.string(),
-	definition: ProcessDefinitionSchema,
-	options: v.optional(RestartingProcessOptionsSchema),
+	definition: ProcessDefinition,
+	options: v.optional(RestartingProcessOptions),
 	envFile: v.optional(v.string()),
-	envReloadDelay: v.optional(EnvReloadDelaySchema),
-	port: v.optional(v.number())
+	envReloadDelay: v.optional(EnvReloadDelay)
 });
-const TaskEntrySchema = v.object({
+const TaskEntry = v.object({
 	name: v.string(),
-	definition: ProcessDefinitionSchema,
+	definition: ProcessDefinition,
 	envFile: v.optional(v.string())
 });
-const ManagerConfigSchema = v.object({
-	http: v.optional(HttpServerConfigSchema),
+const ManagerConfig = v.object({
+	http: v.optional(HttpServerConfig),
 	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))
+	envFile: v.optional(v.string()),
+	tasks: v.optional(v.array(TaskEntry)),
+	crons: v.optional(v.array(CronProcessEntry)),
+	processes: v.optional(v.array(RestartingProcessEntry))
 });
 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();
@@ -291,48 +265,93 @@ var Manager = class {
 	processEnvReloadConfig = /* @__PURE__ */ new Map();
 	envReloadTimers = /* @__PURE__ */ new Map();
 	envChangeUnsubscribe = null;
-	processPortConfig = /* @__PURE__ */ new Map();
 	signalHandlers = /* @__PURE__ */ new Map();
 	shutdownPromise = null;
 	isShuttingDown = false;
 	constructor(config, logger) {
+		const cwd$1 = config.cwd ?? cwd();
 		this.config = config;
 		this.logger = logger;
-		this.logDir = config.logDir ?? join(cwd(), "logs");
+		this.logDir = config.logDir ?? join(cwd$1, "logs");
 		this.ensureLogDirs();
+		this.validateConfigNames();
+		const customEnvFiles = {};
+		for (const task of config.tasks ?? []) if (task.envFile) customEnvFiles[task.name] = task.envFile;
+		for (const cron of config.crons ?? []) if (cron.envFile) customEnvFiles[cron.name] = cron.envFile;
+		for (const proc of config.processes ?? []) if (proc.envFile) customEnvFiles[proc.name] = proc.envFile;
 		this.envManager = new EnvManager({
-			cwd: config.cwd,
-			files: config.envFiles,
-			watch: true
+			cwd: cwd$1,
+			globalEnvFile: config.envFile,
+			customEnvFiles
+		});
+		this.envChangeUnsubscribe = this.envManager.onChange((event) => this.handleEnvChange(event));
+		for (const signal of ["SIGINT", "SIGTERM"]) {
+			const handler = () => this.handleSignal(signal);
+			this.signalHandlers.set(signal, handler);
+			process.on(signal, handler);
+		}
+	}
+	validateConfigNames() {
+		const allNames = [];
+		for (const task of this.config.tasks ?? []) allNames.push({
+			name: task.name,
+			type: "task"
 		});
-		this.envChangeUnsubscribe = this.envManager.onChange((changedKeys) => {
-			this.handleEnvChange(changedKeys);
+		for (const cron of this.config.crons ?? []) allNames.push({
+			name: cron.name,
+			type: "cron"
 		});
-		this.registerShutdownHandlers();
+		for (const proc of this.config.processes ?? []) allNames.push({
+			name: proc.name,
+			type: "process"
+		});
+		const seen = /* @__PURE__ */ new Map();
+		for (const { name, type } of allNames) {
+			const existingType = seen.get(name);
+			if (existingType) throw new Error(`Duplicate name "${name}" found: already used as ${existingType}, cannot use as ${type}. Names must be globally unique across tasks, crons, and processes.`);
+			seen.set(name, type);
+		}
 	}
 	/**
-	* Merge global env with process-specific env and apply cwd inheritance
-	* Merge order: .env (global), config.env (global), .env.<processName>, processEnvFile, definition.env
+	* Check if a name is already used by any task, cron, or process
 	*/
-	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);
+	isNameUsed(name) {
+		for (const task of this.config.tasks ?? []) if (task.name === name) return {
+			used: true,
+			type: "task"
+		};
+		if (this.taskList) {
+			for (const task of this.taskList.tasks) for (const proc of task.processes) if (proc.name === name) return {
+				used: true,
+				type: "task"
+			};
 		}
+		if (this.cronProcesses.has(name)) return {
+			used: true,
+			type: "cron"
+		};
+		for (const cron of this.config.crons ?? []) if (cron.name === name) return {
+			used: true,
+			type: "cron"
+		};
+		if (this.restartingProcesses.has(name)) return {
+			used: true,
+			type: "process"
+		};
+		for (const proc of this.config.processes ?? []) if (proc.name === name) return {
+			used: true,
+			type: "process"
+		};
+		return { used: false };
+	}
+	applyDefaults(processName, definition) {
+		const envVarsFromManager = this.envManager.getEnvVars(processName);
 		return {
 			...definition,
 			cwd: definition.cwd ?? this.config.cwd,
 			env: {
-				...envFromFiles,
+				...envVarsFromManager,
 				...this.config.env,
-				...envFromCustomFile,
 				...definition.env
 			}
 		};
@@ -346,14 +365,6 @@ var Manager = class {
 	cronLogFile(name) {
 		return join(this.logDir, "cron", `${name}.log`);
 	}
-	/**
-	* Kill any process running on the configured port for a process
-	*/
-	async killPortForProcess(processName) {
-		const port = this.processPortConfig.get(processName);
-		if (port === void 0) return;
-		if (await killProcessOnPort(port)) this.logger.info(`Killed process on port ${port} before starting "${processName}"`);
-	}
 	ensureLogDirs() {
 		mkdirSync(this.logDir, { recursive: true });
 		mkdirSync(join(this.logDir, "process"), { recursive: true });
@@ -363,18 +374,21 @@ var Manager = class {
 	/**
 	* Handle env file changes
 	*/
-	handleEnvChange(changedKeys) {
+	handleEnvChange(event) {
 		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);
+		if (event.type === "global") {
+			this.logger.info("Global env file changed, reloading all processes as per their policies");
+			for (const processName of this.restartingProcesses.keys()) {
+				const reloadDelay = this.processEnvReloadConfig.get(processName);
+				if (reloadDelay === false) continue;
+				this.scheduleProcessReload(processName, reloadDelay);
+			}
+			return;
 		}
-		for (const processName of affectedProcesses) {
+		if (event.type === "process") {
+			const processName = event.key;
 			const reloadDelay = this.processEnvReloadConfig.get(processName);
-			if (reloadDelay === false) continue;
+			if (reloadDelay === false) return;
 			this.scheduleProcessReload(processName, reloadDelay);
 		}
 	}
@@ -411,7 +425,7 @@ var Manager = class {
 			this.logger.warn(`Process config for "${processName}" not found`);
 			return;
 		}
-		const updatedDefinition = this.applyDefaults(processName, processConfig.definition, processConfig.envFile);
+		const updatedDefinition = this.applyDefaults(processName, processConfig.definition);
 		await proc.reload(updatedDefinition, true);
 	}
 	get state() {
@@ -490,7 +504,6 @@ var Manager = class {
 	async startProcessByTarget(target) {
 		const proc = this.getProcessByTarget(target);
 		if (!proc) throw new Error(`Process not found: ${target}`);
-		await this.killPortForProcess(proc.name);
 		proc.start();
 		return proc;
 	}
@@ -509,7 +522,6 @@ var Manager = class {
 	async restartProcessByTarget(target, force = false) {
 		const proc = this.getProcessByTarget(target);
 		if (!proc) throw new Error(`Process not found: ${target}`);
-		await this.killPortForProcess(proc.name);
 		await proc.restart(force);
 		return proc;
 	}
@@ -539,7 +551,10 @@ var Manager = class {
 	* Add a task to the task list
 	* Creates the task list if it doesn't exist and starts it
 	*/
-	addTask(name, definition) {
+	addTask(name, definition, envFile) {
+		const nameCheck = this.isNameUsed(name);
+		if (nameCheck.used) throw new Error(`Name "${name}" is already used as ${nameCheck.type}. Names must be globally unique across tasks, crons, and processes.`);
+		if (envFile) this.envManager.registerFile(name, envFile);
 		if (!this.taskList) this.taskList = new TaskList("runtime", this.logger.child("tasks", { logFile: this.taskLogFile("tasks") }), void 0, (processName) => {
 			return this.taskLogFile(processName);
 		});
@@ -567,15 +582,13 @@ var Manager = class {
 	/**
 	* Add a restarting process at runtime
 	*/
-	async addProcess(name, definition, options, envReloadDelay, port) {
-		if (this.restartingProcesses.has(name)) throw new Error(`Process "${name}" already exists`);
+	async addProcess(name, definition, options, envReloadDelay, envFile) {
+		const nameCheck = this.isNameUsed(name);
+		if (nameCheck.used) throw new Error(`Name "${name}" is already used as ${nameCheck.type}. Names must be globally unique across tasks, crons, and processes.`);
+		if (envFile) this.envManager.registerFile(name, envFile);
 		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);
-		if (port !== void 0) {
-			this.processPortConfig.set(name, port);
-			await this.killPortForProcess(name);
-		}
 		restartingProcess.start();
 		this.processEnvReloadConfig.set(name, envReloadDelay ?? 5e3);
 		this.logger.info(`Added and started restarting process: ${name}`);
@@ -621,7 +634,7 @@ var Manager = class {
 			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)
+				process: this.applyDefaults(task.name, task.definition)
 			})), (processName) => {
 				return this.taskLogFile(processName);
 			});
@@ -637,19 +650,15 @@ var Manager = class {
 		}
 		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);
+			const cronProcess = new CronProcess(entry.name, this.applyDefaults(entry.name, entry.definition), 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);
+			const restartingProcess = new RestartingProcess(entry.name, this.applyDefaults(entry.name, entry.definition), entry.options ?? DEFAULT_RESTART_OPTIONS, processLogger);
 			this.restartingProcesses.set(entry.name, restartingProcess);
-			if (entry.port !== void 0) {
-				this.processPortConfig.set(entry.name, entry.port);
-				await this.killPortForProcess(entry.name);
-			}
 			restartingProcess.start();
 			this.processEnvReloadConfig.set(entry.name, entry.envReloadDelay ?? 5e3);
 			this.logger.info(`Started restarting process: ${entry.name}`);
@@ -663,7 +672,6 @@ var Manager = class {
 	async stop(timeout) {
 		if (this._state === "idle" || this._state === "stopped") {
 			this._state = "stopped";
-			this.unregisterShutdownHandlers();
 			return;
 		}
 		this._state = "stopping";
@@ -674,42 +682,15 @@ var Manager = class {
 			this.envChangeUnsubscribe();
 			this.envChangeUnsubscribe = null;
 		}
-		this.envManager.dispose();
+		this.envManager.close();
+		for (const [signal, handler] of this.signalHandlers) process.off(signal, handler);
+		this.signalHandlers.clear();
 		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)
@@ -753,8 +734,8 @@ var Manager = class {
 		this.isShuttingDown = true;
 		this.shutdownPromise = this.performShutdown();
 		this.shutdownPromise.then(() => {
-			this.logger.info(`Exiting with code ${SHUTDOWN_EXIT_CODE}`);
-			process.exit(SHUTDOWN_EXIT_CODE);
+			this.logger.info(`Exiting with code 0`);
+			process.exit();
 		}).catch((err) => {
 			this.logger.error(`Shutdown error:`, err);
 			process.exit(1);
@@ -781,64 +762,126 @@ var Manager = class {
 };
 
 //#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" });
+//#region src/utils.ts
+async function tImport(path) {
 	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;
+		return await import(path);
+	} catch {
+		const { tsImport } = await import("tsx/esm/api");
+		return await tsImport(path, { parentURL: import.meta.url });
+	}
+}
+
+//#endregion
+//#region package.json
+var version = "0.0.0-dev.6";
+
+//#endregion
+//#region src/cli.ts
+const os$1 = os.$context().$meta({});
+const ResourceTarget = v.union([v.string(), v.number()]);
+function printProcessTable(proc) {
+	const table = new Table({ head: [
+		"Name",
+		"State",
+		"Restarts"
+	] });
+	table.push([
+		proc.name,
+		proc.state,
+		proc.restarts
+	]);
+	console.log(table.toString());
+}
+function printTaskTable(task) {
+	const table = new Table({ head: [
+		"Id",
+		"State",
+		"Processes"
+	] });
+	table.push([
+		task.id,
+		task.state,
+		task.processNames.join(", ")
+	]);
+	console.log(table.toString());
+}
+function printCronTable(cron) {
+	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());
+}
+const cliRouter = os$1.router({
+	init: os.meta({
+		description: "Initialize and run the process manager with config file",
+		aliases: { options: { config: "c" } }
+	}).input(v.object({ config: v.optional(v.pipe(v.string(), v.description("Path to config file")), "pidnap.config.ts") })).handler(async ({ input }) => {
+		process.title = "pidnap";
+		const initLogger = logger({ name: "pidnap" });
+		try {
+			const configUrl = pathToFileURL(resolve(process.cwd(), input.config)).href;
+			const configModule = await tImport(configUrl);
+			const rawConfig = configModule.default.default || configModule.default || configModule.config || {};
+			const config = v.parse(ManagerConfig, rawConfig);
+			const host = config.http?.host ?? "127.0.0.1";
+			const port = config.http?.port ?? 9876;
+			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 }
+				const { matched } = await handler.handle(req, res, {
+					prefix: "/rpc",
+					context: { manager }
+				});
+				if (matched) return;
+				res.statusCode = 404;
+				res.end("Not found\n");
 			});
-			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();
+			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);
+		}
+	}),
+	status: os$1.meta({ description: "Show manager status" }).handler(async ({ context: { client } }) => {
+		const status = await client.manager.status();
 		const table = new Table({ head: [
 			"State",
 			"Processes",
@@ -852,356 +895,194 @@ program.command("status").description("Show manager status").option("-u, --url <
 			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);
-	}
+	}),
+	process: os$1.router({
+		list: os$1.meta({ description: "List restarting processes" }).handler(async ({ context: { client } }) => {
+			const processes = await client.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());
+		}),
+		get: os$1.meta({
+			description: "Get a restarting process by name or index",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Process name or index")) })).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.get({ target: input.target }));
+		}),
+		add: os$1.meta({
+			description: "Add a restarting process",
+			aliases: { options: {
+				name: "n",
+				definition: "d"
+			} }
+		}).input(v.object({
+			name: v.pipe(v.string(), v.description("Process name")),
+			definition: v.pipe(ProcessDefinition, v.description("Process definition JSON"))
+		})).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.add({
+				name: input.name,
+				definition: input.definition
+			}));
+		}),
+		start: os$1.meta({
+			description: "Start a restarting process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Process name or index")) })).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.start({ target: input.target }));
+		}),
+		stop: os$1.meta({
+			description: "Stop a restarting process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Process name or index")) })).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.stop({ target: input.target }));
+		}),
+		restart: os$1.meta({
+			description: "Restart a restarting process",
+			aliases: { options: {
+				target: "t",
+				force: "f"
+			} }
+		}).input(v.object({
+			target: v.pipe(ResourceTarget, v.description("Process name or index")),
+			force: v.optional(v.pipe(v.boolean(), v.description("Force restart")))
+		})).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.restart({
+				target: input.target,
+				force: input.force
+			}));
+		}),
+		reload: os$1.meta({
+			description: "Reload a restarting process definition",
+			aliases: { options: {
+				target: "t",
+				definition: "d",
+				restartImmediately: "r"
+			} }
+		}).input(v.object({
+			target: v.pipe(ResourceTarget, v.description("Process name or index")),
+			definition: v.pipe(ProcessDefinition, v.description("Process definition JSON")),
+			restartImmediately: v.optional(v.pipe(v.boolean(), v.description("Restart immediately after reload")))
+		})).handler(async ({ input, context: { client } }) => {
+			printProcessTable(await client.processes.reload({
+				target: input.target,
+				definition: input.definition,
+				restartImmediately: input.restartImmediately
+			}));
+		}),
+		remove: os$1.meta({
+			description: "Remove a restarting process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Process name or index")) })).handler(async ({ input, context: { client } }) => {
+			await client.processes.remove({ target: input.target });
+			console.log("Process removed");
+		})
+	}),
+	tasks: os$1.router({
+		list: os$1.meta({ description: "List tasks" }).handler(async ({ context: { client } }) => {
+			const tasks = await client.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());
+		}),
+		get: os$1.meta({
+			description: "Get a task by id or index",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Task id or index")) })).handler(async ({ input, context: { client } }) => {
+			printTaskTable(await client.tasks.get({ target: input.target }));
+		}),
+		add: os$1.meta({
+			description: "Add a task",
+			aliases: { options: {
+				name: "n",
+				definition: "d"
+			} }
+		}).input(v.object({
+			name: v.pipe(v.string(), v.description("Task name")),
+			definition: v.pipe(ProcessDefinition, v.description("Process definition JSON"))
+		})).handler(async ({ input, context: { client } }) => {
+			printTaskTable(await client.tasks.add({
+				name: input.name,
+				definition: input.definition
+			}));
+		}),
+		remove: os$1.meta({
+			description: "Remove a task by id or index",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Task id or index")) })).handler(async ({ input, context: { client } }) => {
+			printTaskTable(await client.tasks.remove({ target: input.target }));
+		})
+	}),
+	crons: os$1.router({
+		list: os$1.meta({ description: "List cron processes" }).handler(async ({ context: { client } }) => {
+			const crons = await client.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());
+		}),
+		get: os$1.meta({
+			description: "Get a cron process by name or index",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Cron name or index")) })).handler(async ({ input, context: { client } }) => {
+			printCronTable(await client.crons.get({ target: input.target }));
+		}),
+		trigger: os$1.meta({
+			description: "Trigger a cron process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Cron name or index")) })).handler(async ({ input, context: { client } }) => {
+			printCronTable(await client.crons.trigger({ target: input.target }));
+		}),
+		start: os$1.meta({
+			description: "Start a cron process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Cron name or index")) })).handler(async ({ input, context: { client } }) => {
+			printCronTable(await client.crons.start({ target: input.target }));
+		}),
+		stop: os$1.meta({
+			description: "Stop a cron process",
+			aliases: { options: { target: "t" } }
+		}).input(v.object({ target: v.pipe(ResourceTarget, v.description("Cron name or index")) })).handler(async ({ input, context: { client } }) => {
+			printCronTable(await client.crons.stop({ target: input.target }));
+		})
+	})
 });
-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();
+const client = createClient();
+createCli({
+	name: "pidnap",
+	version,
+	router: cliRouter,
+	context: { client }
+}).run({ formatError(error) {
+	if (error?.cause?.code === "ECONNREFUSED") return `Failed to connect to RPC server, are you sure the server is running? If the Server is running of different url, use PIDNAP_RPC_URL environment variable to set it.\n` + format(error);
+	return format(error);
+} });
 
 //#endregion
 export {  };