Build HTTP server for admin API

src/admin-ui/README.md

@@ -1,10 +1,87 @@
 # admin-ui
 
-This package provides the admin UI for Kloak.
+This package provides the HTTP API server for Kloak deployments.
 
-Responsibilities:
+## Responsibilities
 
-- show deployments, versions, drift, and reconciliation history
-- guide provisioning and rollout flows
-- surface repair failures and exceptional actions
-- keep the workflow focused and opinionated
+- Expose core deployment operations (create, list, status updates)
+- Route HTTP requests to CoreService handlers
+- Serialize/deserialize deployments to/from JSON
+- Handle request validation and error responses
+
+## Starting the Server
+
+```bash
+node --experimental-transform-types src/admin-ui/cli.ts
+```
+
+Set port and host via environment variables:
+```bash
+PORT=3000 HOST=localhost node --experimental-transform-types src/admin-ui/cli.ts
+```
+
+## HTTP API
+
+### POST /deployments
+Create a new deployment.
+
+**Request:**
+```json
+{
+  "customerId": "acme",
+  "name": "production",
+  "target": {
+    "createDatabase": true,
+    "createIngress": true,
+    "createDns": true,
+    "createSecrets": true
+  }
+}
+```
+
+**Response:** `201 Created` with deployment object.
+
+### GET /deployments
+List all deployments.
+
+**Response:** `200 OK` with array of deployments.
+
+### GET /deployments/:id
+Get a specific deployment.
+
+**Response:** `200 OK` with deployment object, or `404 Not Found`.
+
+### POST /deployments/:id/versions
+Create a new deployment version.
+
+**Request:**
+```json
+{
+  "createdBy": "alice@example.com",
+  "notes": "Update auth settings",
+  "snapshot": {
+    "keycloakConfig": {...},
+    "authProviders": [...]
+  }
+}
+```
+
+**Response:** `201 Created` with version object.
+
+### PUT /deployments/:id/status
+Update deployment status.
+
+**Request:**
+```json
+{
+  "status": "healthy"
+}
+```
+
+**Response:** `200 OK` with updated deployment object.
+
+## Architecture
+
+- `handler.ts`: HTTP request routing and CoreApi bridging
+- `server.ts`: Node HTTP server wrapper with route matching
+- `cli.ts`: Command-line entry point

src/admin-ui/cli.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {startServer} from './server.ts';
+
+const port = parseInt(process.env.PORT || '3000', 10);
+const host = process.env.HOST || 'localhost';
+
+startServer({port, host}).catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});

src/admin-ui/server.ts

@@ -0,0 +1,115 @@
+import type {Server} from 'node:http';
+import {createServer} from 'node:http';
+
+import {CoreService} from '../core/index.ts';
+import {InMemoryDeploymentRepository} from '../core/index.ts';
+import type {HttpMethod, HttpRequest, HttpResponse} from './handler.ts';
+import {AdminHandler} from './handler.ts';
+
+export interface ServerConfig {
+  readonly port: number;
+  readonly host?: string;
+}
+
+function matchRoute(path: string, pattern: string): Record<string, string>|null {
+  const patternSegments = pattern.split('/');
+  const pathSegments = path.split('/');
+  if (patternSegments.length !== pathSegments.length) return null;
+
+  const params: Record<string, string> = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSeg = patternSegments[i];
+    if (patternSeg.startsWith(':')) {
+      params[patternSeg.slice(1)] = pathSegments[i];
+    } else if (patternSeg !== pathSegments[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+
+function findRoutePattern(path: string): string|null {
+  const patterns = [
+    '/deployments/:id/versions',
+    '/deployments/:id/status',
+    '/deployments/:id',
+    '/deployments',
+  ];
+
+  for (const pattern of patterns) {
+    if (matchRoute(path, pattern)) {
+      return pattern;
+    }
+  }
+  return null;
+}
+
+async function readBody(req: NodeJS.ReadableStream): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', (chunk) => {
+      data += chunk.toString();
+    });
+    req.on('end', () => {
+      if (!data) {
+        resolve(undefined);
+        return;
+      }
+      try {
+        resolve(JSON.parse(data));
+      } catch (e) {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+export async function startServer(config: ServerConfig): Promise<Server> {
+  const repository = new InMemoryDeploymentRepository();
+  const core = new CoreService(repository);
+  const handler = new AdminHandler(core);
+
+  const server = createServer(async (req, res) => {
+    try {
+      const method = (req.method || 'GET') as HttpMethod;
+      const pathname = new URL(req.url || '/', `http://${req.headers.host}`).pathname;
+
+      const routePattern = findRoutePattern(pathname);
+      if (!routePattern) {
+        res.writeHead(404, {'Content-Type': 'application/json'});
+        res.end(JSON.stringify({error: 'Not found'}));
+        return;
+      }
+
+      const params = matchRoute(pathname, routePattern);
+      const body = method === 'GET' ? undefined : await readBody(req);
+
+      const httpRequest: HttpRequest = {
+        method,
+        path: routePattern,
+        params: params || {},
+        body,
+      };
+
+      const httpResponse = await handler.handle(httpRequest);
+
+      const headers: Record<string, string> = {'Content-Type': 'application/json'};
+      res.writeHead(httpResponse.status, headers);
+      res.end(JSON.stringify(httpResponse.body));
+    } catch (error) {
+      console.error('Handler error:', error);
+      res.writeHead(500, {'Content-Type': 'application/json'});
+      res.end(JSON.stringify({error: 'Internal server error'}));
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    const host = config.host || 'localhost';
+    server.listen(config.port, host, () => {
+      console.log(`Server listening on http://${host}:${config.port}`);
+      resolve(server);
+    });
+    server.on('error', reject);
+  });
+}