anbaric-cloud-hosting 1.34.0 → 1.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.34.0",
+  "version": "1.36.0",
   "description": "Anbaric Cloud hosting service: Postgres-backed job persistence and queuing exposed over an HTTP API",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -18,18 +18,18 @@
     "@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.34.0",
-    "anbaric-plugins": "^1.34.0",
-    "anbaric-tsapi": "^1.34.0",
-    "anbaric-web": "^1.34.0",
+    "anbaric-data-store": "^1.36.0",
+    "anbaric-plugins": "^1.36.0",
+    "anbaric-tsapi": "^1.36.0",
+    "anbaric-web": "^1.36.0",
     "esbuild": "^0.28.2",
     "pg": "^8.16.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/pg": "^8.15.0",
-    "anbaric-impl-cloud": "^1.34.0",
-    "anbaric-state-machine": "^1.34.0",
+    "anbaric-impl-cloud": "^1.36.0",
+    "anbaric-state-machine": "^1.36.0",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2"
   },

package/src/app-management/DockerBuildLayer.ts

@@ -108,6 +108,7 @@ class DockerBuildLayer extends BaseBuildLayer {
             "--env", "ANBARIC_AUDITOR_TYPE=cloud",
             "--env", "ANBARIC_SESSION_RESOLVER_TYPE=cloud",
             "--env", "ANBARIC_ENTITLEMENTS_TYPE=cloud",
+            "--env", "ANBARIC_PROMPT_MANAGER_TYPE=cloud",
             "--env", "ANBARIC_NOTIFIER_TYPE=cloud",
             "--env", `ANBARIC_CONSUMER_PORT=${deployment.consumerPort}`,
             "--env", `ANBARIC_CONSUMER_URL=http://${container}:${deployment.consumerPort}`,

package/src/app-management/FargateBuildLayer.ts

@@ -198,6 +198,7 @@ class FargateBuildLayer extends BaseBuildLayer {
                     { name: "ANBARIC_AUDITOR_TYPE", value: "cloud" },
                     { name: "ANBARIC_SESSION_RESOLVER_TYPE", value: "cloud" },
                     { name: "ANBARIC_ENTITLEMENTS_TYPE", value: "cloud" },
+                    { name: "ANBARIC_PROMPT_MANAGER_TYPE", value: "cloud" },
                     { name: "ANBARIC_NOTIFIER_TYPE", value: "cloud" },
                     { name: "ANBARIC_CONSUMER_PORT", value: String(deployment.consumerPort) },
                     { name: "ANBARIC_CONSUMER_URL", value: `http://${deployment.appHost}:${deployment.consumerPort}` },

package/src/auth/HttpMembershipService.ts

@@ -0,0 +1,44 @@
+import {Inviter, MembershipService, PendingInvitation} from "./MembershipService";
+
+type FetchFn = (url : string, init : RequestInit) => Promise<Response>;
+
+/* Talks to the central login's invitation endpoints for one tenant, with the
+   same central api key the platform already holds for CLI key lookups. */
+class HttpMembershipService implements MembershipService {
+
+    constructor(private centralUrl : string, private secret : string, private tenantSlug : string,
+                private fetchFn : FetchFn = (url, init) => fetch(url, init)) {}
+
+    async invite(email : string, invitedBy : Inviter) : Promise<PendingInvitation> {
+        const response = await this.call("POST", "", { email, invitedBy });
+        return await response.json() as PendingInvitation;
+    }
+
+    async pending() : Promise<Array<PendingInvitation>> {
+        const response = await this.call("GET", "");
+        return await response.json() as Array<PendingInvitation>;
+    }
+
+    async revoke(token : string) : Promise<boolean> {
+        const response = await this.call("DELETE", `/${encodeURIComponent(token)}`, undefined, [404]);
+        return response.status === 204;
+    }
+
+    private async call(method : string, path : string, body? : unknown, tolerated : Array<number> = []) : Promise<Response> {
+        const headers : Record<string, string> = { "x-anbaric-central-key": this.secret };
+        if (body !== undefined) headers["content-type"] = "application/json";
+
+        const response = await this.fetchFn(
+            `${this.centralUrl.replace(/\/$/, "")}/tenants/${encodeURIComponent(this.tenantSlug)}/invitations${path}`,
+            { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });
+
+        if (! response.ok && ! tolerated.includes(response.status)) {
+            const problem = await response.json().catch(() => ({})) as { error? : string };
+            throw new Error(problem.error ?? `The invitation request failed with status ${response.status}`);
+        }
+        return response;
+    }
+
+}
+
+export { HttpMembershipService }

package/src/auth/InMemoryMembershipService.ts

@@ -0,0 +1,38 @@
+import {randomUUID} from "node:crypto";
+import {Inviter, MembershipService, PendingInvitation} from "./MembershipService";
+
+class InMemoryMembershipService implements MembershipService {
+
+    private invitations = new Map<string, PendingInvitation>();
+
+    constructor(private linkBase : string = "http://localhost/invitations") {}
+
+    async invite(email : string, invitedBy : Inviter) : Promise<PendingInvitation> {
+        const token = randomUUID();
+        const now = new Date();
+        const invitation : PendingInvitation = {
+            token,
+            email: email.trim().toLowerCase(),
+            role: "member",
+            invitedBy: invitedBy.id,
+            invitedByName: invitedBy.name,
+            link: `${this.linkBase}/${token}`,
+            createdAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+            emailed: false,
+        };
+        this.invitations.set(token, invitation);
+        return { ...invitation };
+    }
+
+    async pending() : Promise<Array<PendingInvitation>> {
+        return Array.from(this.invitations.values()).map(invitation => ({ ...invitation })).reverse();
+    }
+
+    async revoke(token : string) : Promise<boolean> {
+        return this.invitations.delete(token);
+    }
+
+}
+
+export { InMemoryMembershipService }

package/src/auth/MembershipService.ts

@@ -0,0 +1,35 @@
+type PendingInvitation = {
+
+    token : string,
+    email : string,
+    role : string,
+    invitedBy : string,
+    invitedByName? : string,
+    link : string,
+    createdAt : string,
+    expiresAt : string,
+    emailed? : boolean,
+
+};
+
+type Inviter = {
+
+    id : string,
+    name? : string,
+
+};
+
+/* Invitations into this tenant. Membership itself is decided wherever people
+   sign in (Anbaric Cloud's central login), so a platform only asks that
+   service to invite, list and revoke on the tenant's behalf. */
+interface MembershipService {
+
+    invite(email : string, invitedBy : Inviter) : Promise<PendingInvitation>;
+
+    pending() : Promise<Array<PendingInvitation>>;
+
+    revoke(token : string) : Promise<boolean>;
+
+}
+
+export type { MembershipService, PendingInvitation, Inviter }

package/src/data-store/PostgresPromptManager.ts

@@ -0,0 +1,87 @@
+import {Pool} from "pg";
+import {JsonSchema, Prompt, PromptManager, samePromptContent} from "anbaric-tsapi";
+
+const COLUMNS = "app_id, prompt_id, version, instructions, input_schema, output_schema, created_at";
+
+const rowToPrompt = (row : any) : Prompt => ({
+    appId: row.app_id,
+    promptId: row.prompt_id,
+    version: row.version,
+    instructions: row.instructions,
+    inputSchema: row.input_schema ?? undefined,
+    outputSchema: row.output_schema ?? undefined,
+    createdAt: row.created_at instanceof Date ? row.created_at.toISOString() : String(row.created_at),
+});
+
+/* Saving reads the latest version and writes the next inside one transaction,
+   with the latest row locked, so two saves of the same prompt cannot both
+   claim the same version number. */
+class PostgresPromptManager implements PromptManager {
+
+    constructor(private pool : Pool, private appId : string) {}
+
+    async save(promptId : string, instructions : string, inputSchema? : JsonSchema, outputSchema? : JsonSchema) : Promise<Prompt> {
+        const client = await this.pool.connect();
+
+        try {
+            await client.query("BEGIN");
+            const latest = await client.query(
+                `SELECT ${COLUMNS} FROM prompts WHERE app_id = $1 AND prompt_id = $2
+                 ORDER BY version DESC LIMIT 1 FOR UPDATE`, [this.appId, promptId]);
+            const current = latest.rows[0] && rowToPrompt(latest.rows[0]);
+
+            if (current && samePromptContent(current, instructions, inputSchema, outputSchema)) {
+                await client.query("COMMIT");
+                return current;
+            }
+
+            const inserted = await client.query(
+                `INSERT INTO prompts (app_id, prompt_id, version, instructions, input_schema, output_schema)
+                 VALUES ($1, $2, $3, $4, $5, $6)
+                 RETURNING ${COLUMNS}`,
+                [this.appId, promptId, (current?.version ?? 0) + 1, instructions,
+                 inputSchema === undefined ? null : JSON.stringify(inputSchema),
+                 outputSchema === undefined ? null : JSON.stringify(outputSchema)]);
+            await client.query("COMMIT");
+            return rowToPrompt(inserted.rows[0]);
+        } catch (error) {
+            await client.query("ROLLBACK").catch(() => {});
+            throw error;
+        } finally {
+            client.release();
+        }
+    }
+
+    async retrieve(promptId : string, version? : number) : Promise<Prompt> {
+        const result = version === undefined
+            ? await this.pool.query(
+                `SELECT ${COLUMNS} FROM prompts WHERE app_id = $1 AND prompt_id = $2 ORDER BY version DESC LIMIT 1`,
+                [this.appId, promptId])
+            : await this.pool.query(
+                `SELECT ${COLUMNS} FROM prompts WHERE app_id = $1 AND prompt_id = $2 AND version = $3`,
+                [this.appId, promptId, version]);
+        if (! result.rows[0]) {
+            throw new Error(version === undefined
+                ? `No prompt found with id "${promptId}"`
+                : `No prompt found with id "${promptId}" at version ${version}`);
+        }
+        return rowToPrompt(result.rows[0]);
+    }
+
+    async list() : Promise<Array<Prompt>> {
+        const result = await this.pool.query(
+            `SELECT DISTINCT ON (prompt_id) ${COLUMNS} FROM prompts
+             WHERE app_id = $1 ORDER BY prompt_id, version DESC`, [this.appId]);
+        return result.rows.map(rowToPrompt);
+    }
+
+    async history(promptId : string) : Promise<Array<Prompt>> {
+        const result = await this.pool.query(
+            `SELECT ${COLUMNS} FROM prompts WHERE app_id = $1 AND prompt_id = $2 ORDER BY version DESC`,
+            [this.appId, promptId]);
+        return result.rows.map(rowToPrompt);
+    }
+
+}
+
+export { PostgresPromptManager }

package/src/data-store/Schema.ts

@@ -144,6 +144,18 @@ const ensureSchema = async (pool : Pool) : Promise<void> => {
         VALUES (NULL, 'access', 'Global access')
         ON CONFLICT (COALESCE(app_id, ''), entitlement_id) DO NOTHING
     `);
+    await pool.query(`
+        CREATE TABLE IF NOT EXISTS prompts (
+            app_id         TEXT NOT NULL,
+            prompt_id      TEXT NOT NULL,
+            version        INTEGER NOT NULL,
+            instructions   TEXT NOT NULL,
+            input_schema   JSONB,
+            output_schema  JSONB,
+            created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+            PRIMARY KEY (app_id, prompt_id, version)
+        )
+    `);
     await pool.query("CREATE SCHEMA IF NOT EXISTS anbaric_system");
     await pool.query(`
         CREATE TABLE IF NOT EXISTS anbaric_system.cli_keys (

package/src/hosting/HostingServer.ts

@@ -1,4 +1,4 @@
-import {JobPersistence, JobRunSchedulePersistence, JsonStore, Notifier, SecretStore} from "anbaric-tsapi";
+import {JobPersistence, JobRunSchedulePersistence, JsonStore, Notifier, PromptManager, SecretStore} from "anbaric-tsapi";
 import {BuildLayer} from "../app-management/BuildLayer";
 import {AuditRecordStore} from "../auditing/AuditRecordStore";
 import {Authenticator} from "../auth/Authenticator";
@@ -14,6 +14,9 @@ import {AuthorizeCliHandler} from "./handlers/auth/AuthorizeCliHandler";
 import {KeysHandler} from "./handlers/auth/KeysHandler";
 import {SessionsHandler} from "./handlers/auth/SessionsHandler";
 import {UsersHandler} from "./handlers/auth/UsersHandler";
+import {InvitationsHandler} from "./handlers/auth/InvitationsHandler";
+import {PromptsHandler} from "./handlers/PromptsHandler";
+import {MembershipService} from "../auth/MembershipService";
 import {WhoamiHandler} from "./handlers/auth/WhoamiHandler";
 import {UserDirectory} from "../auth/UserDirectory";
 import {ConsumersHandler} from "./handlers/ConsumersHandler";
@@ -65,7 +68,9 @@ class HostingServer {
                 jobRunSchedules? : JobRunSchedulePersistence,
                 notifier? : Notifier,
                 entitlements? : EntitlementStore,
-                userDirectory? : UserDirectory) {
+                userDirectory? : UserDirectory,
+                memberships? : MembershipService,
+                promptManagerFor? : (appId : string) => PromptManager) {
         const pages = new PagesHandler();
         const ping = new PingHandler(tenant);
         const jobs = new JobsHandler(persistence);
@@ -96,6 +101,9 @@ class HostingServer {
         if (notifier) publicRouter.registerApi("notifications", new NotificationsHandler(notifier));
         if (entitlements) publicRouter.registerApi("entitlements", new EntitlementsAdminHandler(entitlements));
         if (userDirectory) publicRouter.registerApi("users", new UsersHandler(userDirectory));
+        if (memberships) publicRouter.registerApi("invitations", new InvitationsHandler(memberships));
+        const prompts = promptManagerFor && new PromptsHandler(promptManagerFor);
+        if (prompts) publicRouter.registerApi("prompts", prompts);
         if (cliAuthorizer) {
             publicRouter.register("authorize-cli", new AuthorizeCliHandler(cliAuthorizer, pages, tenant));
             publicRouter.registerApi("keys", new KeysHandler(cliAuthorizer));
@@ -121,6 +129,7 @@ class HostingServer {
         if (jobRunSchedules) internalRouter.registerApi("job-run-schedules", new JobRunSchedulesHandler(jobRunSchedules));
         if (notifier) internalRouter.registerApi("notifications", new NotificationsHandler(notifier));
         if (entitlements) internalRouter.registerApi("entitlements", new EntitlementsHandler(entitlements));
+        if (prompts) internalRouter.registerApi("prompts", prompts);
 
         // The favicon is requested by the browser before anyone has signed in,
         // and by deployed apps' pages, so gating it behind a session would send

package/src/hosting/handlers/PromptsHandler.ts

@@ -0,0 +1,46 @@
+import {PromptManager} from "anbaric-tsapi";
+import {Request} from "../Request";
+import {RequestHandler} from "../RequestHandler";
+
+/* Prompts belong to the calling app (the ambient app header): save a version,
+   fetch the latest or a named one, list, and read a prompt's history. */
+class PromptsHandler implements RequestHandler {
+
+    constructor(private managerFor : (appId : string) => PromptManager) {}
+
+    async handle(request : Request) : Promise<void> {
+        const appId = request.appId;
+        if (! appId) return request.reply(400, { error: "Missing the x-anbaric-app header" });
+
+        const manager = this.managerFor(appId);
+        const { method, id, subresource } = request;
+
+        if (method === "GET" && ! id) return request.reply(200, await manager.list());
+        if (method === "PUT" && id && ! subresource) return this.save(request, manager, id);
+        if (method === "GET" && id && ! subresource) return this.retrieve(request, manager, id);
+        if (method === "GET" && id && subresource === "history") return request.reply(200, await manager.history(id));
+        request.notFound();
+    }
+
+    private async save(request : Request, manager : PromptManager, promptId : string) : Promise<void> {
+        const body = await request.body() as { instructions? : string, inputSchema? : object, outputSchema? : object } | undefined;
+        if (typeof body?.instructions !== "string") return request.reply(400, { error: "instructions is required" });
+
+        request.reply(200, await manager.save(promptId, body.instructions, body.inputSchema, body.outputSchema));
+    }
+
+    private async retrieve(request : Request, manager : PromptManager, promptId : string) : Promise<void> {
+        const raw = request.query("version");
+        const version = raw === undefined ? undefined : Number(raw);
+        if (version !== undefined && ! Number.isInteger(version)) return request.reply(400, { error: `"${raw}" is not a version` });
+
+        try {
+            request.reply(200, await manager.retrieve(promptId, version));
+        } catch (error) {
+            request.reply(404, { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+
+}
+
+export { PromptsHandler }

package/src/hosting/handlers/auth/InvitationsHandler.ts

@@ -0,0 +1,34 @@
+import {MembershipService} from "../../../auth/MembershipService";
+import {Request} from "../../Request";
+import {RequestHandler} from "../../RequestHandler";
+
+const EMAIL_SHAPE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+/* The console's side of inviting people into this tenant: list what is
+   pending, invite by email (attributed to the signed-in user), revoke. */
+class InvitationsHandler implements RequestHandler {
+
+    constructor(private memberships : MembershipService) {}
+
+    async handle(request : Request) : Promise<void> {
+        if (request.method === "GET" && ! request.id) return request.reply(200, await this.memberships.pending());
+        if (request.method === "POST" && ! request.id) return this.invite(request);
+        if (request.method === "DELETE" && request.id && ! request.subresource) {
+            const revoked = await this.memberships.revoke(request.id);
+            return revoked ? request.reply(204) : request.notFound();
+        }
+        request.notFound();
+    }
+
+    private async invite(request : Request) : Promise<void> {
+        const body = await request.body() as { email? : string } | undefined;
+        const email = String(body?.email ?? "").trim();
+        if (! EMAIL_SHAPE.test(email)) return request.reply(400, { error: "A valid email address is required" });
+
+        const inviter = request.user ? { id: request.user.id, name: request.user.name } : { id: "system" };
+        request.reply(201, await this.memberships.invite(email, inviter));
+    }
+
+}
+
+export { InvitationsHandler }

package/src/index.ts

@@ -21,6 +21,12 @@ export * from "./auth/UserDirectory";
 export * from "./auth/InMemoryUserDirectory";
 export * from "./data-store/PostgresUserDirectory";
 export * from "./hosting/handlers/auth/UsersHandler";
+export * from "./auth/MembershipService";
+export * from "./auth/HttpMembershipService";
+export * from "./auth/InMemoryMembershipService";
+export * from "./hosting/handlers/auth/InvitationsHandler";
+export * from "./data-store/PostgresPromptManager";
+export * from "./hosting/handlers/PromptsHandler";
 export * from "./app-management/DockerBuildLayer";
 export * from "./app-management/FargateBuildLayer";
 export * from "./app-admin/AdminServer";

package/src/main.ts

@@ -22,6 +22,8 @@ import {GatewayDocModel} from "./docs/GatewayDocModel";
 import {PostgresAppDocsStore} from "./data-store/PostgresAppDocsStore";
 import {PostgresEntitlementStore} from "./data-store/PostgresEntitlementStore";
 import {PostgresUserDirectory} from "./data-store/PostgresUserDirectory";
+import {HttpMembershipService} from "./auth/HttpMembershipService";
+import {PostgresPromptManager} from "./data-store/PostgresPromptManager";
 import {ConsumerRegistry} from "./queuing/ConsumerRegistry";
 import {Dispatcher} from "./queuing/Dispatcher";
 import {HostingServer} from "./hosting/HostingServer";
@@ -93,11 +95,18 @@ const tokenAuthenticator = new TokenAuthenticator(cliKeyStore, process.env.ANBAR
 
 const plugins = await new PluginLoader().load(process.env.ANBARIC_PLUGINS ?? "anbaric-plugins/state-machines");
 
+// Invitations are managed by the central login that issued this tenant, which
+// is the same service the CLI key lookup already points at.
+const memberships = process.env.ANBARIC_CLI_KEY_LOOKUP_URL && process.env.ANBARIC_TENANT
+    ? new HttpMembershipService(process.env.ANBARIC_CLI_KEY_LOOKUP_URL, process.env.ANBARIC_CLI_KEY_LOOKUP_SECRET ?? "", process.env.ANBARIC_TENANT)
+    : undefined;
+
 const server = new HostingServer(new PostgresJobPersistence(pool), queue, registry, buildLayer,
     (appId, collection) => new PostgresJsonStore(pool, appId, collection), secretStoreFor, authenticator, cliAuthorizer,
     tokenAuthenticator, process.env.ANBARIC_TENANT, new PostgresAuditRecordStore(pool), plugins,
     new PostgresJobRunSchedulePersistence(pool), await loadNotifier(process.env.ANBARIC_NOTIFIER_MODULE),
-    new PostgresEntitlementStore(pool), new PostgresUserDirectory(pool));
+    new PostgresEntitlementStore(pool), new PostgresUserDirectory(pool), memberships,
+    (appId) => new PostgresPromptManager(pool, appId));
 const port = await server.listen(hostingPort);
 const internal = await server.listenInternal(internalPort);