feat: add v0.1 runtime skeleton

src/mgr/server.ts

@@ -0,0 +1,116 @@
+import type { Server } from "node:http";
+import { createServer } from "node:http";
+import type { AddressInfo } from "node:net";
+import type { AgentRunStore } from "./store.js";
+import { MemoryAgentRunStore } from "./store.js";
+import { AgentRunError, errorToJson } from "../common/errors.js";
+import { asRecord, validateCreateCommand, validateCreateRun } from "../common/validation.js";
+import type { ApiErrorBody, ApiOkBody, JsonRecord, JsonValue, RunEvent } from "../common/types.js";
+
+export interface ManagerServerOptions {
+  store?: AgentRunStore;
+  port?: number;
+  host?: string;
+  sourceCommit?: string;
+}
+
+export interface StartedManagerServer {
+  server: Server;
+  baseUrl: string;
+  store: AgentRunStore;
+}
+
+export async function startManagerServer(options: ManagerServerOptions = {}): Promise<StartedManagerServer> {
+  const store = options.store ?? new MemoryAgentRunStore();
+  const sourceCommit = options.sourceCommit ?? process.env.AGENTRUN_SOURCE_COMMIT ?? "unknown";
+  const server = createServer(async (req, res) => {
+    const traceId = `trc_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      const method = req.method ?? "GET";
+      const url = new URL(req.url ?? "/", "http://agentrun.local");
+      const data = await route({ method, url, body: await readBody(req), store, sourceCommit });
+      writeJson(res, 200, { ok: true, data, traceId });
+    } catch (error) {
+      const agentError = normalizeError(error);
+      writeJson(res, agentError.httpStatus, { ok: false, failureKind: agentError.failureKind, message: agentError.message, traceId, error: errorToJson(error) });
+    }
+  });
+  await new Promise<void>((resolve) => server.listen(options.port ?? 0, options.host ?? "127.0.0.1", resolve));
+  const address = server.address() as AddressInfo;
+  return { server, baseUrl: `http://${address.address}:${address.port}`, store };
+}
+
+async function readBody(req: import("node:http").IncomingMessage): Promise<unknown> {
+  if (req.method === "GET" || req.method === "HEAD") return null;
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (text.length === 0) return null;
+  return JSON.parse(text) as unknown;
+}
+
+async function route({ method, url, body, store, sourceCommit }: { method: string; url: URL; body: unknown; store: AgentRunStore; sourceCommit: string }): Promise<JsonValue> {
+  const path = url.pathname;
+  if (method === "GET" && (path === "/health" || path === "/health/live" || path === "/health/readiness")) {
+    return { serviceId: "agentrun-mgr", live: true, ready: true, database: { adapter: "memory-self-test", migrationReady: true }, sourceCommit, secretRefs: { valuesPrinted: false } };
+  }
+  if (method === "GET" && path === "/api/v1/backends") return { items: store.backends() };
+  if (method === "POST" && path === "/api/v1/runs") return store.createRun(validateCreateRun(body)) as unknown as JsonValue;
+  const runMatch = path.match(/^\/api\/v1\/runs\/([^/]+)$/u);
+  if (method === "GET" && runMatch) return store.getRun(runMatch[1] ?? "") as unknown as JsonValue;
+  const eventMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/events$/u);
+  if (method === "GET" && eventMatch) {
+    const afterSeq = integerQuery(url, "afterSeq", 0);
+    const limit = integerQuery(url, "limit", 100);
+    return { items: store.listEvents(eventMatch[1] ?? "", afterSeq, limit) as unknown as JsonValue };
+  }
+  const commandCreateMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/commands$/u);
+  if (method === "POST" && commandCreateMatch) return store.createCommand(commandCreateMatch[1] ?? "", validateCreateCommand(body)) as unknown as JsonValue;
+  if (method === "GET" && commandCreateMatch) return { items: store.listCommands(commandCreateMatch[1] ?? "", integerQuery(url, "afterSeq", 0), integerQuery(url, "limit", 20)) as unknown as JsonValue };
+  const commandShowMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/commands\/([^/]+)$/u);
+  if (method === "GET" && commandShowMatch) return store.getCommand(commandShowMatch[2] ?? "") as unknown as JsonValue;
+  if (method === "POST" && path === "/api/v1/runners/register") return store.registerRunner(asRecord(body ?? {}, "runner")) as unknown as JsonValue;
+  const claimMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/claim$/u);
+  if (method === "POST" && claimMatch) {
+    const record = asRecord(body, "claim");
+    const runnerId = typeof record.runnerId === "string" ? record.runnerId : "";
+    if (runnerId.length === 0) throw new AgentRunError("schema-invalid", "runnerId is required", { httpStatus: 400 });
+    return store.claimRun(claimMatch[1] ?? "", runnerId, numberField(record, "leaseMs", 60_000)) as unknown as JsonValue;
+  }
+  const eventsAppendMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/events$/u);
+  if (method === "POST" && eventsAppendMatch) {
+    const record = asRecord(body, "event");
+    const type = typeof record.type === "string" ? record.type as RunEvent["type"] : "backend_status";
+    return store.appendEvent(eventsAppendMatch[1] ?? "", type, asRecord(record.payload ?? {}, "event.payload")) as unknown as JsonValue;
+  }
+  const statusMatch = path.match(/^\/api\/v1\/runs\/([^/]+)\/status$/u);
+  if (method === "PATCH" && statusMatch) {
+    const record = asRecord(body, "status");
+    const terminalStatus = record.terminalStatus === "completed" || record.terminalStatus === "failed" || record.terminalStatus === "blocked" || record.terminalStatus === "cancelled" ? record.terminalStatus : "failed";
+    return store.finishRun(statusMatch[1] ?? "", { terminalStatus, failureKind: typeof record.failureKind === "string" ? record.failureKind as never : null, failureMessage: typeof record.failureMessage === "string" ? record.failureMessage : null }) as unknown as JsonValue;
+  }
+  const ackMatch = path.match(/^\/api\/v1\/commands\/([^/]+)\/ack$/u);
+  if (method === "POST" && ackMatch) return store.ackCommand(ackMatch[1] ?? "") as unknown as JsonValue;
+  throw new AgentRunError("schema-invalid", `unsupported route ${method} ${path}`, { httpStatus: 404 });
+}
+
+function integerQuery(url: URL, key: string, fallback: number): number {
+  const value = Number(url.searchParams.get(key));
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function numberField(record: JsonRecord, key: string, fallback: number): number {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function normalizeError(error: unknown): AgentRunError {
+  if (error instanceof AgentRunError) return error;
+  return new AgentRunError("infra-failed", error instanceof Error ? error.message : String(error), { httpStatus: 500 });
+}
+
+function writeJson(res: import("node:http").ServerResponse, statusCode: number, body: ApiOkBody | ApiErrorBody): void {
+  const text = `${JSON.stringify(body)}\n`;
+  res.writeHead(statusCode, { "content-type": "application/json; charset=utf-8", "content-length": Buffer.byteLength(text) });
+  res.end(text);
+}