anbaric-cloud-hosting 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Anbaric Cloud hosting service: Postgres-backed job persistence and queuing exposed over an HTTP API",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -17,15 +17,15 @@
     "@aws-sdk/client-s3": "^3.1110.0",
     "@aws-sdk/client-secrets-manager": "^3.700.0",
     "@aws-sdk/client-servicediscovery": "^3.1110.0",
-    "anbaric-data-store": "^1.4.0",
-    "anbaric-tsapi": "^1.4.0",
+    "anbaric-data-store": "^1.6.0",
+    "anbaric-tsapi": "^1.6.0",
     "pg": "^8.16.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/pg": "^8.15.0",
-    "anbaric-cloud": "^1.4.0",
-    "anbaric-state-machine": "^1.4.0",
+    "anbaric-impl-cloud": "^1.6.0",
+    "anbaric-state-machine": "^1.6.0",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2"
   },

package/src/hosting/HostingServer.ts

@@ -1,130 +1,117 @@
-import {createServer, IncomingMessage, Server, ServerResponse} from "node:http";
-import {AddressInfo} from "node:net";
 import {JobPersistence, JsonStore, SecretStore} from "anbaric-tsapi";
 import {BuildLayer} from "../app-management/BuildLayer";
 import {AuditRecordStore} from "../auditing/AuditRecordStore";
-import {Authenticator, SESSION_COOKIE} from "../auth/Authenticator";
+import {Authenticator} from "../auth/Authenticator";
 import {CliAuthorizer} from "../auth/CliAuthorizer";
-import {Tenant} from "../auth/Tenant";
 import {TokenAuthenticator} from "../auth/TokenAuthenticator";
-import {User} from "../auth/User";
 import {ConfirmableQueue} from "../queuing/ConfirmableQueue";
 import {ConsumerRegistry} from "../queuing/ConsumerRegistry";
+import {AppProxyHandler} from "./handlers/AppProxyHandler";
+import {AppsHandler} from "./handlers/AppsHandler";
+import {AuditsHandler} from "./handlers/AuditsHandler";
+import {AuthorizeCliHandler} from "./handlers/auth/AuthorizeCliHandler";
+import {KeysHandler} from "./handlers/auth/KeysHandler";
+import {WhoamiHandler} from "./handlers/auth/WhoamiHandler";
+import {ConsumersHandler} from "./handlers/ConsumersHandler";
+import {DocumentsHandler} from "./handlers/DocumentsHandler";
+import {JobsHandler} from "./handlers/JobsHandler";
+import {PagesHandler} from "./handlers/PagesHandler";
+import {PingHandler} from "./handlers/PingHandler";
+import {QueueHandler} from "./handlers/QueueHandler";
+import {SecretsHandler} from "./handlers/SecretsHandler";
+import {StateMachinesHandler} from "./handlers/StateMachinesHandler";
+import {AuthenticationMiddleware} from "./middleware/AuthenticationMiddleware";
+import {SessionMiddleware} from "./middleware/SessionMiddleware";
+import {Request} from "./Request";
 import {Router} from "./Router";
+import {Server} from "./Server";
 
-const INTERNAL_RESOURCES = new Set(["jobs", "queue", "consumers", "state-machines", "documents", "secrets", "audits"]);
+const CLI_KEY_POLL = /^\/authorize-cli\/[^/]+\/poll$/;
 
+/* The composition root: builds the handlers from the platform's
+   collaborators, registers them on the public and internal routers, and
+   runs one Server per entry point. The public server authenticates through
+   its middleware chain; the internal server exposes only the workflow
+   handlers, unauthenticated, and must never be publicly reachable. */
 class HostingServer {
 
-    private server : Server;
+    private publicServer : Server;
     private internalServer : Server;
-    private router : Router;
 
     constructor(persistence : JobPersistence, queue : ConfirmableQueue,
                 registry : ConsumerRegistry = new ConsumerRegistry(),
                 buildLayer? : BuildLayer,
                 documentStoreFor? : (collection : string) => JsonStore,
                 secretStore? : SecretStore,
-                private authenticator? : Authenticator,
+                authenticator? : Authenticator,
                 cliAuthorizer? : CliAuthorizer,
-                private tokenAuthenticator? : TokenAuthenticator,
-                private tenant? : string,
+                tokenAuthenticator? : TokenAuthenticator,
+                tenant? : string,
                 auditRecords? : AuditRecordStore) {
-        this.router = new Router(persistence, queue, registry, buildLayer, documentStoreFor, secretStore, cliAuthorizer, tenant, auditRecords);
-        this.server = this.serverFor((request, response) => this.handle(request, response));
-        this.internalServer = this.serverFor((request, response) => this.handleInternal(request, response));
-    }
-
-    listen(port : number) : Promise<number> {
-        return new Promise(resolve =>
-            this.server.listen(port, () => resolve((this.server.address() as AddressInfo).port)));
-    }
-
-    listenInternal(port : number) : Promise<number> {
-        return new Promise(resolve =>
-            this.internalServer.listen(port, () => resolve((this.internalServer.address() as AddressInfo).port)));
-    }
-
-    close() : Promise<void> {
-        return new Promise((resolve, reject) => {
-            if (this.internalServer.listening) this.internalServer.close();
-            this.server.close(error => error ? reject(error) : resolve());
-        });
-    }
-
-    private serverFor(handle : (request : IncomingMessage, response : ServerResponse) => Promise<void>) : Server {
-        return createServer((request, response) => {
-            handle(request, response).catch(error => {
-                const message = error instanceof Error ? error.message : "Internal error";
-                const status = /^No .+ found/.test(message) ? 404 : 500;
-                this.reply(response, status, { error: message });
-            });
-        });
-    }
-
-    private async handle(request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        const path = request.url?.split("?")[0] ?? "/";
-        if (path === "/ping" && request.method === "GET") {
-            return this.reply(response, 200, this.tenant ? { status: "ok", tenant: this.tenant } : { status: "ok" });
+        const pages = new PagesHandler();
+        const ping = new PingHandler(tenant);
+        const jobs = new JobsHandler(persistence);
+        const queueHandler = new QueueHandler(queue);
+        const consumers = new ConsumersHandler(registry);
+        const stateMachines = new StateMachinesHandler(registry);
+        const documents = documentStoreFor && new DocumentsHandler(documentStoreFor);
+        const secrets = secretStore && new SecretsHandler(secretStore);
+        const audits = auditRecords && new AuditsHandler(auditRecords);
+
+        const publicRouter = new Router();
+        publicRouter.registerRoot(pages);
+        publicRouter.register("ping", ping);
+        publicRouter.register("audit", pages);
+        publicRouter.register("whoami", new WhoamiHandler());
+        publicRouter.register("jobs", jobs);
+        publicRouter.register("queue", queueHandler);
+        publicRouter.register("consumers", consumers);
+        publicRouter.register("state-machines", stateMachines);
+        if (documents) publicRouter.register("documents", documents);
+        if (secrets) publicRouter.register("secrets", secrets);
+        if (audits) publicRouter.register("audits", audits);
+        if (cliAuthorizer) {
+            publicRouter.register("authorize-cli", new AuthorizeCliHandler(cliAuthorizer, pages, tenant));
+            publicRouter.register("keys", new KeysHandler(cliAuthorizer));
+            publicRouter.register("manage-keys", pages);
         }
-        if (/^\/authorize-cli\/[^/]+\/poll$/.test(path) && request.method === "GET") {
-            return this.router.route(request, response);
+        if (buildLayer) {
+            publicRouter.register("apps", new AppsHandler(buildLayer));
+            publicRouter.registerFallback(new AppProxyHandler(buildLayer));
         }
 
-        if (this.tokenAuthenticator?.handles(request)) {
-            const user = await this.tokenAuthenticator.authenticate(request, response);
-            if (!user) return;
-            return this.authorizeAndRoute(user, undefined, request, response);
-        }
-
-        const authenticated = await this.authenticateSession(request, response);
-        if (this.authenticator && !authenticated) return;
-        if (authenticated) return this.authorizeAndRoute(authenticated[0], authenticated[1], request, response);
-
-        await this.router.route(request, response);
-    }
-
-    private async handleInternal(request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        const path = request.url?.split("?")[0] ?? "/";
-        if (path === "/ping" && request.method === "GET") {
-            return this.reply(response, 200, this.tenant ? { status: "ok", tenant: this.tenant } : { status: "ok" });
-        }
-        const [resource] = path.split("/").filter(Boolean);
-        if (!resource || !INTERNAL_RESOURCES.has(resource)) {
-            return this.reply(response, 404, { error: "Not found" });
-        }
-        await this.router.route(request, response);
+        const internalRouter = new Router();
+        internalRouter.register("ping", ping);
+        internalRouter.register("jobs", jobs);
+        internalRouter.register("queue", queueHandler);
+        internalRouter.register("consumers", consumers);
+        internalRouter.register("state-machines", stateMachines);
+        if (documents) internalRouter.register("documents", documents);
+        if (secrets) internalRouter.register("secrets", secrets);
+        if (audits) internalRouter.register("audits", audits);
+
+        const openRequests = (request : Request) =>
+            request.url.pathname === "/ping" ||
+            (request.method === "GET" && CLI_KEY_POLL.test(request.url.pathname));
+
+        this.publicServer = new Server(publicRouter, [
+            new SessionMiddleware(),
+            new AuthenticationMiddleware(authenticator, tokenAuthenticator, openRequests),
+        ]);
+        this.internalServer = new Server(internalRouter);
     }
 
-    private async authorizeAndRoute(user : User, tenant : Tenant | undefined,
-                                    request : IncomingMessage, response : ServerResponse) : Promise<void> {
-        if (this.authenticator) {
-            const permitted = await this.authenticator.authorize(user, request, response);
-            if (!permitted) {
-                if (!response.writableEnded) this.reply(response, 403, { error: "Not authorized" });
-                return;
-            }
-        }
-        await this.router.route(request, response, user, tenant);
-    }
-
-    private async authenticateSession(request : IncomingMessage, response : ServerResponse) : Promise<[User, Tenant] | undefined> {
-        if (!this.authenticator) return undefined;
-        return this.authenticator.authenticate(this.sessionCookie(request), request, response);
+    listen(port : number) : Promise<number> {
+        return this.publicServer.listen(port);
     }
 
-    private sessionCookie(request : IncomingMessage) : string | undefined {
-        const cookies = String(request.headers.cookie ?? "").split(";");
-        for (const cookie of cookies) {
-            const [name, ...value] = cookie.trim().split("=");
-            if (name === SESSION_COOKIE) return value.join("=");
-        }
-        return undefined;
+    listenInternal(port : number) : Promise<number> {
+        return this.internalServer.listen(port);
     }
 
-    private reply(response : ServerResponse, status : number, body : unknown) : void {
-        response.writeHead(status, { "content-type": "application/json" });
-        response.end(JSON.stringify(body));
+    async close() : Promise<void> {
+        if (this.internalServer.listening) await this.internalServer.close();
+        await this.publicServer.close();
     }
 
 }

package/src/hosting/Middleware.ts

@@ -0,0 +1,11 @@
+import {Request} from "./Request";
+
+/* Runs before routing; may decorate the request or answer it. Returning
+   false stops the chain - the middleware has written the response. */
+interface Middleware {
+
+    apply(request : Request) : Promise<boolean>;
+
+}
+
+export type { Middleware }

package/src/hosting/Request.ts

@@ -0,0 +1,103 @@
+import {randomUUID} from "node:crypto";
+import {IncomingMessage, ServerResponse} from "node:http";
+import {Tenant} from "../auth/Tenant";
+import {User} from "../auth/User";
+
+/* One inbound request: the parsed URL and body plus everything the server's
+   middleware decorates it with - session, user, tenant, ray trace id -
+   before it reaches a handler. Handlers respond through reply/replyHtml and
+   never touch the raw response unless they stream (the app proxy). */
+class Request {
+
+    readonly rayId : string;
+    session? : string;
+    user? : User;
+    tenant? : Tenant;
+
+    private parsed : URL;
+    private segments : Array<string>;
+
+    constructor(private incoming : IncomingMessage, private response : ServerResponse,
+                rayId : string = randomUUID()) {
+        this.rayId = rayId;
+        this.parsed = new URL(incoming.url ?? "/", "http://localhost");
+        this.segments = this.parsed.pathname.split("/").filter(Boolean);
+    }
+
+    get method() : string {
+        return this.incoming.method ?? "GET";
+    }
+
+    get url() : URL {
+        return this.parsed;
+    }
+
+    get resource() : string | undefined {
+        return this.segments[0];
+    }
+
+    get id() : string | undefined {
+        return this.segments[1];
+    }
+
+    get subresource() : string | undefined {
+        return this.segments[2];
+    }
+
+    get raw() : IncomingMessage {
+        return this.incoming;
+    }
+
+    get rawResponse() : ServerResponse {
+        return this.response;
+    }
+
+    get handled() : boolean {
+        return this.response.writableEnded;
+    }
+
+    header(name : string) : string | undefined {
+        const value = this.incoming.headers[name.toLowerCase()];
+        return value === undefined ? undefined : String(value);
+    }
+
+    query(name : string) : string | undefined {
+        return this.parsed.searchParams.get(name) ?? undefined;
+    }
+
+    rawBody() : Promise<Buffer> {
+        return new Promise((resolve, reject) => {
+            const chunks : Array<Buffer> = [];
+            this.incoming.on("data", chunk => chunks.push(chunk));
+            this.incoming.on("error", reject);
+            this.incoming.on("end", () => resolve(Buffer.concat(chunks)));
+        });
+    }
+
+    async body() : Promise<any> {
+        const raw = (await this.rawBody()).toString();
+        return raw.length === 0 ? undefined : JSON.parse(raw);
+    }
+
+    reply(status : number, body? : unknown) : void {
+        if (body === undefined) {
+            this.response.statusCode = status;
+            this.response.end();
+            return;
+        }
+        this.response.writeHead(status, { "content-type": "application/json" });
+        this.response.end(JSON.stringify(body));
+    }
+
+    replyHtml(page : Buffer) : void {
+        this.response.writeHead(200, { "content-type": "text/html" });
+        this.response.end(page);
+    }
+
+    notFound() : void {
+        this.reply(404, { error: "Not found" });
+    }
+
+}
+
+export { Request }

package/src/hosting/RequestHandler.ts

@@ -0,0 +1,9 @@
+import {Request} from "./Request";
+
+interface RequestHandler {
+
+    handle(request : Request) : Promise<void>;
+
+}
+
+export type { RequestHandler }