pidnap 0.0.0-dev.0

package/src/api/server.ts

@@ -0,0 +1,180 @@
+import { implement } from "@orpc/server";
+import {
+  api,
+  type RestartingProcessInfo,
+  type CronProcessInfo,
+  type TaskEntryInfo,
+  type ManagerStatus,
+} from "./contract.ts";
+import type { Manager } from "../manager.ts";
+import type { RestartingProcess } from "../restarting-process.ts";
+import type { CronProcess } from "../cron-process.ts";
+
+const os = implement(api).$context<{ manager: Manager }>();
+
+// Helper to serialize a RestartingProcess to API response
+function serializeProcess(proc: RestartingProcess): RestartingProcessInfo {
+  return {
+    name: proc.name,
+    state: proc.state,
+    restarts: proc.restarts,
+  };
+}
+
+// Helper to serialize a CronProcess to API response
+function serializeCron(cron: CronProcess): CronProcessInfo {
+  return {
+    name: cron.name,
+    state: cron.state,
+    runCount: cron.runCount,
+    failCount: cron.failCount,
+    nextRun: cron.nextRun?.toISOString() ?? null,
+  };
+}
+
+// Manager handlers
+const managerStatus = os.manager.status.handler(async ({ context }): Promise<ManagerStatus> => {
+  const manager = context.manager;
+  const taskList = manager.getTaskList();
+  return {
+    state: manager.state,
+    processCount: manager.getRestartingProcesses().size,
+    cronCount: manager.getCronProcesses().size,
+    taskCount: taskList?.tasks.length ?? 0,
+  };
+});
+
+// Processes handlers
+const getProcess = os.processes.get.handler(async ({ input, context }) => {
+  const proc = context.manager.getProcessByTarget(input.target);
+  if (!proc) {
+    throw new Error(`Process not found: ${input.target}`);
+  }
+  return serializeProcess(proc);
+});
+
+const listProcesses = os.processes.list.handler(async ({ context }) => {
+  const processes = Array.from(context.manager.getRestartingProcesses().values());
+  return processes.map(serializeProcess);
+});
+
+const addProcess = os.processes.add.handler(async ({ input, context }) => {
+  const proc = context.manager.addProcess(input.name, input.definition);
+  return serializeProcess(proc);
+});
+
+const startProcess = os.processes.start.handler(async ({ input, context }) => {
+  const proc = context.manager.startProcessByTarget(input.target);
+  return serializeProcess(proc);
+});
+
+const stopProcess = os.processes.stop.handler(async ({ input, context }) => {
+  const proc = await context.manager.stopProcessByTarget(input.target);
+  return serializeProcess(proc);
+});
+
+const restartProcess = os.processes.restart.handler(async ({ input, context }) => {
+  const proc = await context.manager.restartProcessByTarget(input.target, input.force);
+  return serializeProcess(proc);
+});
+
+const reloadProcess = os.processes.reload.handler(async ({ input, context }) => {
+  const proc = await context.manager.reloadProcessByTarget(input.target, input.definition, {
+    restartImmediately: input.restartImmediately,
+  });
+  return serializeProcess(proc);
+});
+
+const removeProcess = os.processes.remove.handler(async ({ input, context }) => {
+  await context.manager.removeProcessByTarget(input.target);
+  return { success: true };
+});
+
+// Crons handlers
+const getCron = os.crons.get.handler(async ({ input, context }) => {
+  const cron = context.manager.getCronByTarget(input.target);
+  if (!cron) {
+    throw new Error(`Cron not found: ${input.target}`);
+  }
+  return serializeCron(cron);
+});
+
+const listCrons = os.crons.list.handler(async ({ context }) => {
+  const crons = Array.from(context.manager.getCronProcesses().values());
+  return crons.map(serializeCron);
+});
+
+const triggerCron = os.crons.trigger.handler(async ({ input, context }) => {
+  const cron = await context.manager.triggerCronByTarget(input.target);
+  return serializeCron(cron);
+});
+
+const startCron = os.crons.start.handler(async ({ input, context }) => {
+  const cron = context.manager.startCronByTarget(input.target);
+  return serializeCron(cron);
+});
+
+const stopCron = os.crons.stop.handler(async ({ input, context }) => {
+  const cron = await context.manager.stopCronByTarget(input.target);
+  return serializeCron(cron);
+});
+
+// Tasks handlers
+const getTask = os.tasks.get.handler(async ({ input, context }) => {
+  const task = context.manager.getTaskByTarget(input.target);
+  if (!task) {
+    throw new Error(`Task not found: ${input.target}`);
+  }
+  return task as TaskEntryInfo;
+});
+
+const listTasks = os.tasks.list.handler(async ({ context }) => {
+  const taskList = context.manager.getTaskList();
+  if (!taskList) {
+    return [];
+  }
+  return taskList.tasks.map((t) => ({
+    id: t.id,
+    state: t.state,
+    processNames: t.processes.map((p) => p.name),
+  })) as TaskEntryInfo[];
+});
+
+const addTask = os.tasks.add.handler(async ({ input, context }) => {
+  const task = context.manager.addTask(input.name, input.definition);
+  return task as TaskEntryInfo;
+});
+
+const removeTask = os.tasks.remove.handler(async ({ input, context }) => {
+  const task = context.manager.removeTaskByTarget(input.target);
+  return task as TaskEntryInfo;
+});
+
+export const router = os.router({
+  manager: {
+    status: managerStatus,
+  },
+  processes: {
+    add: addProcess,
+    get: getProcess,
+    list: listProcesses,
+    start: startProcess,
+    stop: stopProcess,
+    restart: restartProcess,
+    reload: reloadProcess,
+    remove: removeProcess,
+  },
+  crons: {
+    get: getCron,
+    list: listCrons,
+    trigger: triggerCron,
+    start: startCron,
+    stop: stopCron,
+  },
+  tasks: {
+    get: getTask,
+    list: listTasks,
+    add: addTask,
+    remove: removeTask,
+  },
+});

package/src/cli.ts

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { RPCHandler } from "@orpc/server/node";
+import { onError } from "@orpc/server";
+import * as v from "valibot";
+import { router } from "./api/server.ts";
+import { Manager, ManagerConfigSchema } from "./manager.ts";
+import { logger } from "./logger.ts";
+import { tsImport } from "tsx/esm/api";
+import Table from "cli-table3";
+import { createClient } from "./api/client.ts";
+import { ProcessDefinitionSchema } from "./api/contract.ts";
+
+const program = new Command();
+
+program
+  .name("pidnap")
+  .description("Process manager with init system capabilities")
+  .version("0.0.0-dev.1");
+
+program
+  .command("init")
+  .description("Initialize and run the process manager with config file")
+  .option("-c, --config <path>", "Path to config file", "pidnap.config.ts")
+  .action(async (options) => {
+    const initLogger = logger({ name: "pidnap" });
+    try {
+      // Resolve config file path
+      const configPath = resolve(process.cwd(), options.config);
+      const configUrl = pathToFileURL(configPath).href;
+
+      // Import the config file
+      const configModule = await tsImport(configUrl, { parentURL: import.meta.url });
+      const rawConfig =
+        configModule.default.default || configModule.default || configModule.config || {};
+
+      // Parse and validate the config with Valibot
+      const config = v.parse(ManagerConfigSchema, rawConfig);
+
+      // Extract HTTP config with defaults
+      const host = config.http?.host ?? "localhost";
+      const port = config.http?.port ?? 3000;
+      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 { matched } = await handler.handle(req, res, {
+          prefix: "/rpc",
+          context: { manager },
+        });
+        if (matched) return;
+        res.statusCode = 404;
+        res.end("Not found");
+      });
+
+      server.listen(port, host, async () => {
+        managerLogger.info(`pidnap RPC server running on http://${host}:${port}`);
+        if (authToken) {
+          managerLogger.info("Auth token required for API access");
+        }
+
+        try {
+          await manager.start();
+        } catch (err) {
+          managerLogger.error("Failed to start manager:", err);
+          server.close();
+          process.exit(1);
+        }
+      });
+
+      // Wait for shutdown
+      await manager.waitForShutdown();
+
+      // 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", "http://localhost:3000/rpc")
+  .action(async (options) => {
+    try {
+      const client = createClient(options.url);
+      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 processes = program.command("processes").description("Manage restarting processes");
+
+processes
+  .command("list")
+  .description("List restarting processes")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (options) => {
+    try {
+      const 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);
+    }
+  });
+
+processes
+  .command("get")
+  .description("Get a restarting process by name or index")
+  .argument("<target>", "Process name or index")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      const 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);
+    }
+  });
+
+processes
+  .command("add")
+  .description("Add a restarting process")
+  .requiredOption("-n, --name <name>", "Process name")
+  .requiredOption("-d, --definition <json>", "Process definition JSON")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (options) => {
+    try {
+      const client = createClient(options.url);
+      const definition = parseDefinition(options.definition);
+      const proc = await client.processes.add({ name: options.name, definition });
+
+      const table = new Table({ head: ["Name", "State", "Restarts"] });
+      table.push([proc.name, proc.state, proc.restarts]);
+      console.log(table.toString());
+    } catch (error) {
+      console.error("Failed to add process:", error);
+      process.exit(1);
+    }
+  });
+
+processes
+  .command("start")
+  .description("Start a restarting process")
+  .argument("<target>", "Process name or index")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      const 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);
+    }
+  });
+
+processes
+  .command("stop")
+  .description("Stop a restarting process")
+  .argument("<target>", "Process name or index")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      const 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);
+    }
+  });
+
+processes
+  .command("restart")
+  .description("Restart a restarting process")
+  .argument("<target>", "Process name or index")
+  .option("-f, --force", "Force restart")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      const 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);
+    }
+  });
+
+processes
+  .command("remove")
+  .description("Remove a restarting process")
+  .argument("<target>", "Process name or index")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .action(async (options) => {
+    try {
+      const client = createClient(options.url);
+      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", "http://localhost:3000/rpc")
+  .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", "http://localhost:3000/rpc")
+  .action(async (options) => {
+    try {
+      const client = createClient(options.url);
+      const definition = parseDefinition(options.definition);
+      const task = await client.tasks.add({ name: options.name, definition });
+
+      const table = new Table({ head: ["Id", "State", "Processes"] });
+      table.push([task.id, task.state, task.processNames.join(", ")]);
+      console.log(table.toString());
+    } catch (error) {
+      console.error("Failed to add task:", error);
+      process.exit(1);
+    }
+  });
+
+tasks
+  .command("remove")
+  .description("Remove a task by id or index")
+  .argument("<target>", "Task id or index")
+  .option("-u, --url <url>", "RPC server URL", "http://localhost:3000/rpc")
+  .action(async (target, options) => {
+    try {
+      const 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);
+    }
+  });
+
+const TargetSchema = v.union([v.string(), v.number()]);
+type ProcessDefinition = v.InferOutput<typeof ProcessDefinitionSchema>;
+
+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(ProcessDefinitionSchema, parsed);
+  } catch (error) {
+    console.error("Invalid --definition JSON. Expected a ProcessDefinition.");
+    throw error;
+  }
+}
+
+program.parse();