pidnap 0.0.0-dev.5 → 0.0.0-dev.7

package/dist/cli.mjs

@@ -1,21 +1,22 @@
 #!/usr/bin/env node
-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 { _ as ProcessDefinition, a as TaskStateSchema, c as CronProcessState, h as RestartingProcessState, i as TaskList, m as RestartingProcessOptions, n as logger, o as CronProcess, p as RestartingProcess, s as CronProcessOptions, t as EnvManager } from "./env-manager-FKhvfwIR.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 { cwd } from "node:process";
 import { mkdirSync } from "node:fs";
+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",
@@ -48,51 +49,51 @@ const TaskEntryInfoSchema = v.object({
 });
 const manager = { status: oc$1.output(ManagerStatusSchema) };
 const processes = {
-	get: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
+	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: 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,
+		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: 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,
-	tasks: tasks$1,
-	crons: crons$1
+	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,
@@ -109,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 {
@@ -119,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) => ({
@@ -177,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,
@@ -282,7 +283,7 @@ var Manager = class {
 			cwd: cwd$1,
 			globalEnvFile: config.envFile,
 			customEnvFiles
-		});
+		}, this.logger.child("env-manager"));
 		this.envChangeUnsubscribe = this.envManager.onChange((event) => this.handleEnvChange(event));
 		for (const signal of ["SIGINT", "SIGTERM"]) {
 			const handler = () => this.handleSignal(signal);
@@ -682,6 +683,8 @@ var Manager = class {
 			this.envChangeUnsubscribe = null;
 		}
 		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));
@@ -769,66 +772,116 @@ async function tImport(path) {
 	}
 }
 
+//#endregion
+//#region package.json
+var version = "0.0.0-dev.7";
+
 //#endregion
 //#region src/cli.ts
-const program = new Command();
-program.name("pidnap").description("Process manager with init system capabilities").version("0.0.0-dev.5");
-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) => {
-	process.title = "pidnap";
-	const initLogger = logger({ name: "pidnap" });
-	try {
-		const configUrl = pathToFileURL(resolve(process.cwd(), options.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 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\n");
-		});
-		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").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",
@@ -842,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 processGroup = program.command("process").description("Manage restarting processes");
-processGroup.command("list").description("List restarting processes").option("-u, --url <url>", "RPC server URL").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);
-	}
-});
-processGroup.command("get").description("Get a restarting process by name or index").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL").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);
-	}
-});
-processGroup.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").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);
-	}
-});
-processGroup.command("start").description("Start a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL").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);
-	}
-});
-processGroup.command("stop").description("Stop a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL").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);
-	}
-});
-processGroup.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").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);
-	}
-});
-processGroup.command("remove").description("Remove a restarting process").argument("<target>", "Process name or index").option("-u, --url <url>", "RPC server URL").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").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").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").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);
-	}
+	}),
+	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 }));
+		})
+	})
 });
-crons.command("start").description("Start a cron process").argument("<target>", "Cron name or index").option("-u, --url <url>", "RPC server URL").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").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").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").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").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").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(ProcessDefinition, 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 {  };