pidnap 0.0.0-dev.3 → 0.0.0-dev.5

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/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-BF3KrCIK.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";
@@ -9,11 +9,8 @@ import { RPCHandler } from "@orpc/server/node";
 import { implement, onError } 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 Table from "cli-table3";
 
 //#region src/api/contract.ts
@@ -34,12 +31,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,12 +47,12 @@ const TaskEntryInfoSchema = v.object({
 	processNames: v.array(v.string())
 });
 const manager = { status: oc$1.output(ManagerStatusSchema) };
-const processes$1 = {
+const processes = {
 	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
+		definition: ProcessDefinition
 	})).output(RestartingProcessInfoSchema),
 	start: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
 	stop: oc$1.input(v.object({ target: ResourceTarget })).output(RestartingProcessInfoSchema),
@@ -65,7 +62,7 @@ const processes$1 = {
 	})).output(RestartingProcessInfoSchema),
 	reload: oc$1.input(v.object({
 		target: ResourceTarget,
-		definition: ProcessDefinitionSchema,
+		definition: ProcessDefinition,
 		restartImmediately: v.optional(v.boolean())
 	})).output(RestartingProcessInfoSchema),
 	remove: oc$1.input(v.object({ target: ResourceTarget })).output(v.object({ success: v.boolean() }))
@@ -75,7 +72,7 @@ const tasks$1 = {
 	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)
 };
@@ -88,7 +85,7 @@ const crons$1 = {
 };
 const api = {
 	manager,
-	processes: processes$1,
+	processes,
 	tasks: tasks$1,
 	crons: crons$1
 };
@@ -213,76 +210,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 +264,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 +364,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 +373,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 +424,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 +503,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 +521,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 +550,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 +581,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 +633,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 +649,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 +671,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 +681,13 @@ var Manager = class {
 			this.envChangeUnsubscribe();
 			this.envChangeUnsubscribe = null;
 		}
-		this.envManager.dispose();
+		this.envManager.close();
 		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 +731,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);
@@ -780,19 +758,31 @@ var Manager = class {
 	}
 };
 
+//#endregion
+//#region src/utils.ts
+async function tImport(path) {
+	try {
+		return await import(path);
+	} catch {
+		const { tsImport } = await import("tsx/esm/api");
+		return await tsImport(path, { parentURL: import.meta.url });
+	}
+}
+
 //#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.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 tsImport(configUrl, { parentURL: import.meta.url });
+		const configModule = await tImport(configUrl);
 		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 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",
@@ -816,7 +806,7 @@ program.command("init").description("Initialize and run the process manager with
 			});
 			if (matched) return;
 			res.statusCode = 404;
-			res.end("Not found");
+			res.end("Not found\n");
 		});
 		server.listen(port, host, async () => {
 			managerLogger.info(`pidnap RPC server running on http://${host}:${port}`);
@@ -836,7 +826,7 @@ program.command("init").description("Initialize and run the process manager with
 		process.exit(1);
 	}
 });
-program.command("status").description("Show manager status").option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc").action(async (options) => {
+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();
 		const table = new Table({ head: [
@@ -857,8 +847,8 @@ program.command("status").description("Show manager status").option("-u, --url <
 		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) => {
+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: [
@@ -877,7 +867,7 @@ processes.command("list").description("List restarting processes").option("-u, -
 		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) => {
+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: [
@@ -896,7 +886,7 @@ processes.command("get").description("Get a restarting process by name or index"
 		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) => {
+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);
@@ -920,7 +910,7 @@ processes.command("add").description("Add a restarting process").requiredOption(
 		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) => {
+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: [
@@ -939,7 +929,7 @@ processes.command("start").description("Start a restarting process").argument("<
 		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) => {
+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: [
@@ -958,7 +948,7 @@ processes.command("stop").description("Stop a restarting process").argument("<ta
 		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) => {
+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),
@@ -980,7 +970,7 @@ processes.command("restart").description("Restart a restarting process").argumen
 		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) => {
+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");
@@ -990,7 +980,7 @@ processes.command("remove").description("Remove a restarting process").argument(
 	}
 });
 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) => {
+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: [
@@ -1013,7 +1003,7 @@ crons.command("list").description("List cron processes").option("-u, --url <url>
 		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) => {
+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: [
@@ -1036,7 +1026,7 @@ crons.command("get").description("Get a cron process by name or index").argument
 		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) => {
+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: [
@@ -1059,7 +1049,7 @@ crons.command("trigger").description("Trigger a cron process").argument("<target
 		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) => {
+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: [
@@ -1082,7 +1072,7 @@ crons.command("start").description("Start a cron process").argument("<target>",
 		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) => {
+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: [
@@ -1106,7 +1096,7 @@ crons.command("stop").description("Stop a cron process").argument("<target>", "C
 	}
 });
 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) => {
+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: [
@@ -1125,7 +1115,7 @@ tasks.command("list").description("List tasks").option("-u, --url <url>", "RPC s
 		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) => {
+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: [
@@ -1144,7 +1134,7 @@ tasks.command("get").description("Get a task by id or index").argument("<target>
 		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) => {
+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);
@@ -1168,7 +1158,7 @@ tasks.command("add").description("Add a task").requiredOption("-n, --name <name>
 		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) => {
+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: [
@@ -1195,7 +1185,7 @@ function parseTarget(value) {
 function parseDefinition(raw) {
 	try {
 		const parsed = JSON.parse(raw);
-		return v.parse(ProcessDefinitionSchema, parsed);
+		return v.parse(ProcessDefinition, parsed);
 	} catch (error) {
 		console.error("Invalid --definition JSON. Expected a ProcessDefinition.");
 		throw error;