pid1 0.0.0-dev.0 → 0.0.0-dev.3

package/src/api/server.ts

@@ -1,66 +1,180 @@
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-import { RPCHandler } from "@orpc/server/fetch";
-import { onError } from "@orpc/server";
-import { router } from "./router.ts";
-import type { ProcessManager } from "../process-manager.ts";
-import { globalLogger } from "../logger.ts";
-import { logger as honoLogger } from "hono/logger";
-
-export type ServerOptions = {
-  port?: number;
-  host?: string;
-};
-
-export function createServer(pm: ProcessManager, options: ServerOptions = {}) {
-  const { port = 3000, host = "127.0.0.1" } = options;
-  const logger = globalLogger.child("server");
-
-  const app = new Hono();
-
-  const handler = new RPCHandler(router, {
-    interceptors: [
-      onError((error: unknown) => {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`RPC Error: ${message}`);
-      }),
-    ],
-  });
+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,
+  };
+});
 
-  app.use(
-    honoLogger((msg, ...args) => logger.debug(`${msg} ${args.join(" ")}`)),
-  );
+// 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);
+});
 
-  app.get("/health", (c) => c.json({ status: "ok" }));
+const listProcesses = os.processes.list.handler(async ({ context }) => {
+  const processes = Array.from(context.manager.getRestartingProcesses().values());
+  return processes.map(serializeProcess);
+});
 
-  app.use("/rpc/*", async (c, next) => {
-    const { matched, response } = await handler.handle(c.req.raw, {
-      prefix: "/rpc",
-      context: { pm },
-    });
+const addProcess = os.processes.add.handler(async ({ input, context }) => {
+  const proc = context.manager.addProcess(input.name, input.definition);
+  return serializeProcess(proc);
+});
 
-    if (matched) {
-      return c.newResponse(response.body, response);
-    }
+const startProcess = os.processes.start.handler(async ({ input, context }) => {
+  const proc = context.manager.startProcessByTarget(input.target);
+  return serializeProcess(proc);
+});
 
-    await next();
+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);
+});
 
-  app.notFound((c) => c.json({ error: "Not found" }, 404));
+const removeProcess = os.processes.remove.handler(async ({ input, context }) => {
+  await context.manager.removeProcessByTarget(input.target);
+  return { success: true };
+});
 
-  return {
-    app,
-    start: () => {
-      const server = serve({
-        fetch: app.fetch,
-        port,
-        hostname: host,
-      });
-
-      logger.info(`HTTP server listening on http://${host}:${port}`);
-      return server;
-    },
-  };
-}
+// 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 type { Router } from "./router.ts";
+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,
+  },
+});