pid1 0.0.0-dev.1 → 0.0.0-dev.3

package/src/cli.ts

@@ -1,164 +1,462 @@
 #!/usr/bin/env node
-import Table from "cli-table3";
 import { Command } from "commander";
-import { ProcessManager } from "./process-manager.ts";
+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 { globalLogger } from "./logger.ts";
+import { ProcessDefinitionSchema } from "./api/contract.ts";
 
-const logger = globalLogger.child("cli");
-const defaultPort = Number(process.env.PID1_PORT ?? process.env.PORT ?? 3000);
-const envHost = process.env.PID1_HOST ?? process.env.HOST;
+const program = new Command();
 
-function formatTable(rows: Array<Record<string, unknown>>): void {
-  if (rows.length === 0) {
-    console.log("No processes registered");
-    return;
-  }
+program
+  .name("pid1")
+  .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", "pid1.config.ts")
+  .action(async (options) => {
+    const initLogger = logger({ name: "pid1" });
+    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: "pid1", logFile: resolve(logDir, "pid1.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 table = new Table({
-    head: ["ID", "NAME", "STATUS", "PID", "RESTARTS", "STARTED"],
-    style: { head: [], border: [] },
+      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(`pid1 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 pid1:", error);
+      process.exit(1);
+    }
   });
 
-  for (const row of rows) {
-    table.push([
-      String(row.id),
-      String(row.name),
-      String(row.status),
-      row.pid ? String(row.pid) : "-",
-      String(row.restarts),
-      row.startedAt ? new Date(row.startedAt as string).toLocaleString() : "-",
-    ]);
-  }
+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();
 
-  console.log(table.toString());
-}
+      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);
+    }
+  });
 
-type CommonArgs = {
-  port?: number;
-  host?: string;
-};
-type InitArgs = CommonArgs & {
-  cwd?: string;
-  config?: string;
-};
-
-async function runInit(argv: InitArgs) {
-  const host = argv.host ?? envHost ?? "0.0.0.0";
-  const pm = new ProcessManager({
-    cwd: argv.cwd,
-    configPath: argv.config,
-    server: { port: argv.port ?? defaultPort, host },
-  });
-  pm.serve();
-  await pm.init();
-  pm.startAll();
-}
+const processes = program.command("processes").description("Manage restarting processes");
 
-function createRpcClient(argv: CommonArgs) {
-  const host = argv.host ?? envHost ?? "127.0.0.1";
-  const port = argv.port ?? defaultPort;
-  return createClient({ url: `http://${host}:${port}/rpc` });
-}
+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();
 
-async function main() {
-  const program = new Command();
-  program
-    .name("pid1")
-    .description("Process manager daemon and controller")
-    .option("--port <number>", "Port for the HTTP server", (value) => Number(value))
-    .option("--host <host>", "Host for the HTTP server");
-
-  const commonOptions = (): CommonArgs => {
-    const opts = program.opts<CommonArgs>();
-    return {
-      port: opts.port,
-      host: opts.host,
-    };
-  };
-
-  program
-    .command("init")
-    .description("Start the daemon, run tasks, and start all processes")
-    .option("--cwd <path>", "Working directory for config lookup")
-    .option("--config <path>", "Path to config file")
-    .action(async (options: InitArgs) => {
-      await runInit({ ...commonOptions(), ...options });
-    });
-
-  program
-    .command("start [name]")
-    .description("Start all processes, or a specific process by name or id")
-    .action(async (name?: string) => {
-      const client = createRpcClient(commonOptions());
-      const result = await client.process.start({ name });
-      console.log(result.message);
-    });
-
-  program
-    .command("stop [name]")
-    .description("Stop all processes, or a specific process by name or id")
-    .action(async (name?: string) => {
-      const client = createRpcClient(commonOptions());
-      const result = await client.process.stop({ name });
-      console.log(result.message);
-    });
-
-  program
-    .command("restart [name]")
-    .description("Restart all processes, or a specific process by name or id")
-    .action(async (name?: string) => {
-      const client = createRpcClient(commonOptions());
-      const result = await client.process.restart({ name });
-      console.log(result.message);
-    });
-
-  program
-    .command("delete [name]")
-    .description("Delete all processes, or a specific process by name or id")
-    .action(async (name?: string) => {
-      const client = createRpcClient(commonOptions());
-      const result = await client.process.delete({ name });
-      console.log(result.message);
-    });
-
-  program
-    .command("list")
-    .description("List all managed processes")
-    .action(async () => {
-      const client = createRpcClient(commonOptions());
-      const processes = await client.process.list({});
-      formatTable(processes);
-    });
-
-  program
-    .command("get <name>")
-    .description("Get a process by name or id")
-    .action(async (name: string) => {
-      const client = createRpcClient(commonOptions());
-      const process = await client.process.get({ name });
-      if (!process) {
-        console.log(`Process not found: ${name}`);
-        return;
+      const table = new Table({ head: ["Name", "State", "Restarts"] });
+      for (const proc of processes) {
+        table.push([proc.name, proc.state, proc.restarts]);
       }
-      formatTable([process]);
-    });
+      console.log(table.toString());
+    } catch (error) {
+      console.error("Failed to list processes:", error);
+      process.exit(1);
+    }
+  });
 
-  if (process.argv.length <= 2) {
-    program.outputHelp();
-    return;
-  }
+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) });
 
-  await program.parseAsync(process.argv);
+      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);
 }
 
-main().catch((error) => {
-  if (error.cause?.code === "ECONNREFUSED") {
-    console.error(
-      "Error: Could not connect to pid1 daemon. Is it running? Start it with: pid1 init",
-    );
-    process.exit(1);
+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;
   }
-  logger.error(error instanceof Error ? (error.stack ?? error.message) : String(error));
-  process.exit(1);
-});
+}
+
+program.parse();