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

package/src/cli.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { Command } from "commander";
 import { createServer } from "node:http";
 import { pathToFileURL } from "node:url";
 import { resolve } from "node:path";
@@ -10,453 +9,343 @@ import { router } from "./api/server.ts";
 import { Manager, ManagerConfig } from "./manager.ts";
 import { logger } from "./logger.ts";
 import Table from "cli-table3";
-import { createClient } from "./api/client.ts";
+import { createClient, type Client } from "./api/client.ts";
 import { ProcessDefinition } from "./lazy-process.ts";
 import { tImport } from "./utils.ts";
+import { os as osBase } from "@orpc/server";
+import { createCli, type TrpcCliMeta } from "trpc-cli";
+import { format } from "node:util";
+import pkg from "../package.json" assert { type: "json" };
 
-const program = new Command();
+const os = osBase.$context<{ client: Client }>().$meta<TrpcCliMeta>({});
 
-program
-  .name("pidnap")
-  .description("Process manager with init system capabilities")
-  .version("0.0.0-dev.5");
+const ResourceTarget = v.union([v.string(), v.number()]);
 
-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 {
-      // Resolve config file path
-      const configPath = resolve(process.cwd(), options.config);
-      const configUrl = pathToFileURL(configPath).href;
-
-      // Import the config file
-      const configModule = await tImport(configUrl);
-      const rawConfig =
-        configModule.default.default || configModule.default || configModule.config || {};
-
-      // Parse and validate the config with Valibot
-      const config = v.parse(ManagerConfig, rawConfig);
+// Helper functions for table formatting (used multiple times)
+function printProcessTable(proc: { name: string; state: string; restarts: number }) {
+  const table = new Table({ head: ["Name", "State", "Restarts"] });
+  table.push([proc.name, proc.state, proc.restarts]);
+  console.log(table.toString());
+}
 
-      // Extract HTTP config with defaults
-      const host = config.http?.host ?? "127.0.0.1";
-      const port = config.http?.port ?? 9876;
-      const authToken = config.http?.authToken;
+function printTaskTable(task: { id: string; state: string; processNames: string[] }) {
+  const table = new Table({ head: ["Id", "State", "Processes"] });
+  table.push([task.id, task.state, task.processNames.join(", ")]);
+  console.log(table.toString());
+}
 
-      // Create manager with config
-      const logDir = config.logDir ?? resolve(process.cwd(), "logs");
-      const managerLogger = logger({ name: "pidnap", logFile: resolve(logDir, "pidnap.log") });
-      const manager = new Manager(config, managerLogger);
+function printCronTable(cron: {
+  name: string;
+  state: string;
+  runCount: number;
+  failCount: number;
+  nextRun: string | null;
+}) {
+  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());
+}
 
-      // Setup ORPC server with optional auth token middleware
-      const handler = new RPCHandler(router, {
-        interceptors: [
-          onError((error) => {
-            managerLogger.error(error);
-          }),
-        ],
-      });
+const cliRouter = os.router({
+  init: osBase
+    .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 {
+        // Resolve config file path
+        const configPath = resolve(process.cwd(), input.config);
+        const configUrl = pathToFileURL(configPath).href;
+
+        // Import the config file
+        const configModule = await tImport(configUrl);
+        const rawConfig =
+          configModule.default.default || configModule.default || configModule.config || {};
+
+        // Parse and validate the config with Valibot
+        const config = v.parse(ManagerConfig, rawConfig);
+
+        // Extract HTTP config with defaults
+        const host = config.http?.host ?? "127.0.0.1";
+        const port = config.http?.port ?? 9876;
+        const authToken = config.http?.authToken;
+
+        // Create manager with config
+        const logDir = config.logDir ?? resolve(process.cwd(), "logs");
+        const managerLogger = logger({ name: "pidnap", logFile: resolve(logDir, "pidnap.log") });
+        const manager = new Manager(config, managerLogger);
+
+        // Setup ORPC server with optional auth token middleware
+        const handler = new RPCHandler(router, {
+          interceptors: [
+            onError((error) => {
+              managerLogger.error(error);
+            }),
+          ],
+        });
 
-      const server = createServer(async (req, res) => {
-        // Check auth token if configured
-        if (authToken) {
-          const providedToken = req.headers["authorization"]?.replace("Bearer ", "");
-          if (providedToken !== authToken) {
-            res.statusCode = 401;
-            res.end("Unauthorized");
-            return;
+        const server = createServer(async (req, res) => {
+          // Check auth token if configured
+          if (authToken) {
+            const providedToken = req.headers["authorization"]?.replace("Bearer ", "");
+            if (providedToken !== 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");
-        }
+        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);
-        }
-      });
+          try {
+            await manager.start();
+          } catch (err) {
+            managerLogger.error("Failed to start manager:", err);
+            server.close();
+            process.exit(1);
+          }
+        });
 
-      // Wait for shutdown
-      await manager.waitForShutdown();
+        // Wait for shutdown
+        await manager.waitForShutdown();
 
-      // Close server on shutdown
-      server.close();
-    } catch (error) {
-      initLogger.error("Failed to start pidnap:", error);
-      process.exit(1);
-    }
-  });
+        // Close server on shutdown
+        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 client = createClient(options.url);
+  status: os
+    .meta({ description: "Show manager status" })
+    .handler(async ({ context: { client } }) => {
       const status = await client.manager.status();
-
       const table = new Table({ head: ["State", "Processes", "Crons", "Tasks"] });
       table.push([status.state, status.processCount, status.cronCount, status.taskCount]);
       console.log(table.toString());
-    } catch (error) {
-      console.error("Failed to fetch status:", error);
-      process.exit(1);
-    }
-  });
-
-const 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 client = createClient(options.url);
-      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());
-    } 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 client = createClient(options.url);
-      const proc = await client.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 client = createClient(options.url);
-      const proc = await client.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 client = createClient(options.url);
-      const proc = await client.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 client = createClient(options.url);
-      const proc = await client.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 {
-      const client = createClient(options.url);
-      await client.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 client = createClient(options.url);
-      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());
-    } 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 client = createClient(options.url);
-      const cron = await client.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 client = createClient(options.url);
-      const cron = await client.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")
-  .action(async (target, options) => {
-    try {
-      const client = createClient(options.url);
-      const cron = await client.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 client = createClient(options.url);
-      const cron = await client.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 client = createClient(options.url);
+    }),
+
+  process: os.router({
+    list: os
+      .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
+      .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 } }) => {
+        const proc = await client.processes.get({ target: input.target });
+        printProcessTable(proc);
+      }),
+    add: os
+      .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 } }) => {
+        const proc = await client.processes.add({ name: input.name, definition: input.definition });
+        printProcessTable(proc);
+      }),
+    start: os
+      .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 } }) => {
+        const proc = await client.processes.start({ target: input.target });
+        printProcessTable(proc);
+      }),
+    stop: os
+      .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 } }) => {
+        const proc = await client.processes.stop({ target: input.target });
+        printProcessTable(proc);
+      }),
+    restart: os
+      .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 } }) => {
+        const proc = await client.processes.restart({ target: input.target, force: input.force });
+        printProcessTable(proc);
+      }),
+    reload: os
+      .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 } }) => {
+        const proc = await client.processes.reload({
+          target: input.target,
+          definition: input.definition,
+          restartImmediately: input.restartImmediately,
+        });
+        printProcessTable(proc);
+      }),
+    remove: os
+      .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
+  tasks: os.router({
+    list: os.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());
-    } 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 client = createClient(options.url);
-      const task = await client.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 client = createClient(options.url);
-      const task = await client.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);
+    }),
+    get: os
+      .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 } }) => {
+        const task = await client.tasks.get({ target: input.target });
+        printTaskTable(task);
+      }),
+    add: os
+      .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 } }) => {
+        const task = await client.tasks.add({ name: input.name, definition: input.definition });
+        printTaskTable(task);
+      }),
+    remove: os
+      .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 } }) => {
+        const task = await client.tasks.remove({ target: input.target });
+        printTaskTable(task);
+      }),
+  }),
+
+  // Crons
+  crons: os.router({
+    list: os
+      .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
+      .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 } }) => {
+        const cron = await client.crons.get({ target: input.target });
+        printCronTable(cron);
+      }),
+    trigger: os
+      .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 } }) => {
+        const cron = await client.crons.trigger({ target: input.target });
+        printCronTable(cron);
+      }),
+    start: os
+      .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 } }) => {
+        const cron = await client.crons.start({ target: input.target });
+        printCronTable(cron);
+      }),
+    stop: os
+      .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 } }) => {
+        const cron = await client.crons.stop({ target: input.target });
+        printCronTable(cron);
+      }),
+  }),
+});
+
+const client = createClient();
+const cli = createCli({
+  name: "pidnap",
+  version: pkg.version,
+  router: cliRouter,
+  context: { client },
+});
+
+cli.run({
+  formatError(error: any) {
+    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)
+      );
     }
-  });
-
-const TargetSchema = v.union([v.string(), v.number()]);
-
-function parseTarget(value: string): string | number {
-  const asNumber = Number(value);
-  return v.parse(TargetSchema, Number.isNaN(asNumber) ? value : asNumber);
-}
-
-function parseDefinition(raw: string): ProcessDefinition {
-  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();
+    return format(error);
+  },
+});