@openlup/platform 0.29.0 → 0.30.0

package/dist/operations/errors.js

@@ -0,0 +1,6 @@
+export class PlatformControlPlaneConflictError extends Error {
+    name = "PlatformControlPlaneConflictError";
+}
+export class PlatformControlPlaneUnavailableError extends Error {
+    name = "PlatformControlPlaneUnavailableError";
+}

package/dist/operations/index.d.ts

@@ -0,0 +1,9 @@
+/** Browser-safe operational contracts, validation and operator projections. */
+export * from "./contracts/index.js";
+export * from "./schemas.js";
+export * from "./adminAlertsSchemas.js";
+export * from "./adminAlertsView.js";
+export * from "./alertPagingPolicy.js";
+export * from "./alertThrottlePolicy.js";
+export * from "./errors.js";
+export * from "./clients.js";

package/dist/operations/index.js

@@ -0,0 +1,9 @@
+/** Browser-safe operational contracts, validation and operator projections. */
+export * from "./contracts/index.js";
+export * from "./schemas.js";
+export * from "./adminAlertsSchemas.js";
+export * from "./adminAlertsView.js";
+export * from "./alertPagingPolicy.js";
+export * from "./alertThrottlePolicy.js";
+export * from "./errors.js";
+export * from "./clients.js";

package/dist/operations/schemas.d.ts

@@ -0,0 +1,138 @@
+import { z } from "./validation.js";
+export declare const adminPipelineTesterSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodString;
+    email_sequence_step: z.ZodNullable<z.ZodNumber>;
+    email_sequence_paused: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const adminPipelineEmailTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    sequence_order: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const adminPipelineEmailEventSchema: z.ZodObject<{
+    event_type: z.ZodString;
+}, z.core.$strip>;
+export declare const adminPipelineReadRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const adminPipelineReadResponseSchema: z.ZodObject<{
+    testers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        email_sequence_step: z.ZodNullable<z.ZodNumber>;
+        email_sequence_paused: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    templates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        sequence_order: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    emailSendCount: z.ZodNumber;
+    emailEvents: z.ZodArray<z.ZodObject<{
+        event_type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const adminPipelineDhlTrackingRefreshRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const adminPipelineDhlTrackingRefreshResponseSchema: z.ZodObject<{
+    checked: z.ZodNumber;
+    updated: z.ZodNumber;
+}, z.core.$strip>;
+export declare const adminSettingsReadRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const adminSettingsAdminUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    role: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const adminSettingsReadResponseSchema: z.ZodObject<{
+    settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    adminUsers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+        role: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const adminSettingWriteValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+export declare const adminSettingsUpdateRequestSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+}, z.core.$strip>;
+export declare const adminSettingsUpdateResponseSchema: z.ZodObject<{
+    key: z.ZodString;
+    saved: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export declare const platformControlPlaneReadRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const platformControlPlaneReadResponseSchema: z.ZodObject<{
+    controls: z.ZodArray<z.ZodObject<{
+        controlKey: z.ZodString;
+        enabled: z.ZodBoolean;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    jobs: z.ZodArray<z.ZodObject<{
+        jobName: z.ZodString;
+        enabled: z.ZodBoolean;
+        activeDriver: z.ZodEnum<{
+            operator: "operator";
+            scheduler: "scheduler";
+            worker: "worker";
+        }>;
+        lastStatus: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            skipped: "skipped";
+            success: "success";
+            running: "running";
+        }>>;
+        lastStartedAt: z.ZodNullable<z.ZodString>;
+        lastFinishedAt: z.ZodNullable<z.ZodString>;
+        lastSuccessAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    alerts: z.ZodArray<z.ZodObject<{
+        dedupeKey: z.ZodString;
+        severity: z.ZodEnum<{
+            p0: "p0";
+            p1: "p1";
+            p2: "p2";
+            p3: "p3";
+        }>;
+        status: z.ZodEnum<{
+            open: "open";
+            resolved: "resolved";
+            acknowledged: "acknowledged";
+        }>;
+        owner: z.ZodString;
+        title: z.ZodString;
+        firstSeenAt: z.ZodString;
+        lastSeenAt: z.ZodString;
+        resolvedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const platformControlPlaneMutationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"set-control">;
+    idempotencyKey: z.ZodString;
+    controlKey: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"record-heartbeat">;
+    idempotencyKey: z.ZodString;
+    health: z.ZodEnum<{
+        failed: "failed";
+        degraded: "degraded";
+        healthy: "healthy";
+    }>;
+    firingCount: z.ZodNumber;
+    maxSeverity: z.ZodNullable<z.ZodEnum<{
+        p0: "p0";
+        p1: "p1";
+        p2: "p2";
+        p3: "p3";
+    }>>;
+    promotionReady: z.ZodBoolean;
+}, z.core.$strict>]>;
+export declare const platformControlPlaneMutationResponseSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        "set-control": "set-control";
+        "record-heartbeat": "record-heartbeat";
+    }>;
+    replayed: z.ZodBoolean;
+    revision: z.ZodNullable<z.ZodNumber>;
+    recordedAt: z.ZodString;
+}, z.core.$strip>;

package/dist/operations/schemas.js

@@ -0,0 +1,104 @@
+import { z } from "./validation.js";
+export const adminPipelineTesterSchema = z.object({
+    id: z.string().min(1),
+    status: z.string().min(1),
+    email_sequence_step: z.number().int().min(0).nullable(),
+    email_sequence_paused: z.boolean().nullable(),
+});
+export const adminPipelineEmailTemplateSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    sequence_order: z.number().int().min(0).nullable(),
+});
+export const adminPipelineEmailEventSchema = z.object({
+    event_type: z.string().min(1),
+});
+export const adminPipelineReadRequestSchema = z.object({}).strict();
+export const adminPipelineReadResponseSchema = z.object({
+    testers: z.array(adminPipelineTesterSchema),
+    templates: z.array(adminPipelineEmailTemplateSchema),
+    emailSendCount: z.number().int().min(0),
+    emailEvents: z.array(adminPipelineEmailEventSchema),
+});
+export const adminPipelineDhlTrackingRefreshRequestSchema = z.object({}).strict();
+export const adminPipelineDhlTrackingRefreshResponseSchema = z.object({
+    checked: z.number().int().min(0),
+    updated: z.number().int().min(0),
+});
+export const adminSettingsReadRequestSchema = z.object({}).strict();
+export const adminSettingsAdminUserSchema = z.object({
+    id: z.string().min(1),
+    email: z.string().nullable(),
+    role: z.string().nullable(),
+});
+export const adminSettingsReadResponseSchema = z.object({
+    settings: z.record(z.string(), z.unknown()),
+    adminUsers: z.array(adminSettingsAdminUserSchema),
+});
+export const adminSettingWriteValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
+export const adminSettingsUpdateRequestSchema = z.object({
+    key: z.string().trim().min(1),
+    value: adminSettingWriteValueSchema,
+});
+export const adminSettingsUpdateResponseSchema = z.object({
+    key: z.string().min(1),
+    saved: z.literal(true),
+});
+const platformControlKeySchema = z.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/);
+const platformOperationKeySchema = z.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/);
+const platformTimestampSchema = z.string().datetime({ offset: true });
+export const platformControlPlaneReadRequestSchema = z.object({}).strict();
+export const platformControlPlaneReadResponseSchema = z.object({
+    controls: z.array(z.object({
+        controlKey: platformControlKeySchema,
+        enabled: z.boolean(),
+        revision: z.number().int().min(1),
+        updatedAt: platformTimestampSchema,
+    })),
+    jobs: z.array(z.object({
+        jobName: z.string().min(1),
+        enabled: z.boolean(),
+        activeDriver: z.enum(["worker", "scheduler", "operator"]),
+        lastStatus: z.enum(["running", "success", "failed", "skipped"]).nullable(),
+        lastStartedAt: platformTimestampSchema.nullable(),
+        lastFinishedAt: platformTimestampSchema.nullable(),
+        lastSuccessAt: platformTimestampSchema.nullable(),
+    })),
+    alerts: z.array(z.object({
+        dedupeKey: z.string().min(1),
+        severity: z.enum(["p0", "p1", "p2", "p3"]),
+        status: z.enum(["open", "acknowledged", "resolved"]),
+        owner: z.string().min(1),
+        title: z.string().min(1),
+        firstSeenAt: platformTimestampSchema,
+        lastSeenAt: platformTimestampSchema,
+        resolvedAt: platformTimestampSchema.nullable(),
+    })),
+});
+export const platformControlPlaneMutationSchema = z.union([
+    z.object({
+        action: z.literal("set-control"),
+        idempotencyKey: platformOperationKeySchema,
+        controlKey: platformControlKeySchema,
+        enabled: z.boolean(),
+    }).strict(),
+    z.object({
+        action: z.literal("record-heartbeat"),
+        idempotencyKey: platformOperationKeySchema,
+        health: z.enum(["healthy", "degraded", "failed"]),
+        firingCount: z.number().int().min(0),
+        maxSeverity: z.enum(["p0", "p1", "p2", "p3"]).nullable(),
+        promotionReady: z.boolean(),
+    }).strict(),
+]);
+export const platformControlPlaneMutationResponseSchema = z.object({
+    action: z.enum(["set-control", "record-heartbeat"]),
+    replayed: z.boolean(),
+    revision: z.number().int().min(1).nullable(),
+    recordedAt: platformTimestampSchema,
+});

package/dist/operations/server/adminAlertsHandlers.d.ts

@@ -0,0 +1,16 @@
+import { type BffResponderOptions } from "../../bff/index.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { PlatformAlertLedgerRow, WatchdogHeartbeatRow } from "../index.js";
+import type { OperationsAuthorizationResult } from "../contracts/index.js";
+type AuthorizeAdmin = () => Promise<OperationsAuthorizationResult>;
+export interface AdminAlertsReadPort {
+    listLiveAlerts(): Promise<PlatformAlertLedgerRow[]>;
+    readWatchdogHeartbeat(): Promise<WatchdogHeartbeatRow>;
+}
+export interface AdminAlertsOverviewDeps extends BffResponderOptions {
+    readPort: AdminAlertsReadPort;
+    authorizeAdmin: AuthorizeAdmin;
+    now?: () => Date;
+}
+export declare function createAdminAlertsOverviewHandler({ readPort, authorizeAdmin, now, responseRequestId, }: AdminAlertsOverviewDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export {};

package/dist/operations/server/adminAlertsHandlers.js

@@ -0,0 +1,35 @@
+import { createBffResponder } from "../../bff/index.js";
+import { adminAlertsOverviewResponseSchema } from "../index.js";
+import { buildAlertsOverview } from "../index.js";
+export function createAdminAlertsOverviewHandler({ readPort, authorizeAdmin, now = () => new Date(), responseRequestId, }) {
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = createBffResponder({ responseRequestId });
+    return async function handler(req, res) {
+        if (req.method !== "GET") {
+            sendMethodNotAllowed(res, ["GET"]);
+            return;
+        }
+        const authorization = await authorizeAdmin();
+        if (authorization.ok === false) {
+            sendBffError(res, authorization.code, authorization.message);
+            return;
+        }
+        try {
+            // Heartbeat and alerts are read together: an empty alert list is only
+            // "healthy" if the watchdog actually reported recently.
+            const [alerts, heartbeat] = await Promise.all([
+                readPort.listLiveAlerts(),
+                readPort.readWatchdogHeartbeat(),
+            ]);
+            const overview = buildAlertsOverview(alerts, heartbeat, now());
+            const response = adminAlertsOverviewResponseSchema.safeParse(overview);
+            if (!response.success) {
+                sendBffError(res, "INVALID_RESPONSE", "Admin alerts overview returned invalid response");
+                return;
+            }
+            sendBffSuccess(res, response.data);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin alerts overview failed");
+        }
+    };
+}

package/dist/operations/server/adminPipelineHandlers.d.ts

@@ -0,0 +1,12 @@
+import { type BffResponderOptions } from "../../bff/index.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AdminPipelineReadPort } from "../contracts/index.js";
+import type { OperationsAuthorizationResult } from "../contracts/index.js";
+interface AdminPipelineBaseDeps extends BffResponderOptions {
+    authorizeAdmin: (req: HttpRequest) => Promise<OperationsAuthorizationResult>;
+}
+export interface AdminPipelineReadDeps extends AdminPipelineBaseDeps {
+    pipelinePort: Pick<AdminPipelineReadPort, "readPipeline">;
+}
+export declare function createAdminPipelineReadHandler({ pipelinePort, authorizeAdmin, responseRequestId, }: AdminPipelineReadDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export {};

package/dist/operations/server/adminPipelineHandlers.js

@@ -0,0 +1,48 @@
+import { createBffResponder } from "../../bff/index.js";
+import { adminPipelineReadRequestSchema, adminPipelineReadResponseSchema, } from "../index.js";
+export function createAdminPipelineReadHandler({ pipelinePort, authorizeAdmin, responseRequestId, }) {
+    const responder = createBffResponder({ responseRequestId });
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = responder;
+    return async function handler(req, res) {
+        if (req.method !== "GET") {
+            sendMethodNotAllowed(res, ["GET"]);
+            return;
+        }
+        const authorization = await readAuthorization(req, res, authorizeAdmin, responder);
+        if (!authorization)
+            return;
+        const request = adminPipelineReadRequestSchema.safeParse(req.query);
+        if (!request.success) {
+            sendBffError(res, "BAD_REQUEST", "Invalid admin pipeline read request", {
+                details: request.error.flatten(),
+            });
+            return;
+        }
+        try {
+            const result = await pipelinePort.readPipeline(request.data);
+            const response = adminPipelineReadResponseSchema.safeParse(result);
+            if (!response.success) {
+                sendBffError(res, "INVALID_RESPONSE", "Admin pipeline read returned invalid response");
+                return;
+            }
+            sendBffSuccess(res, response.data);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin pipeline read failed");
+        }
+    };
+}
+async function readAuthorization(req, res, authorizeAdmin, { sendBffError }) {
+    try {
+        const authorization = await authorizeAdmin(req);
+        if (authorization.ok === false) {
+            sendBffError(res, authorization.code, authorization.message);
+            return null;
+        }
+        return true;
+    }
+    catch {
+        sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin authorization failed");
+        return null;
+    }
+}

package/dist/operations/server/adminSettingsHandlers.d.ts

@@ -0,0 +1,14 @@
+import { type BffResponderOptions } from "../../bff/index.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AdminSettingsOperationsPort } from "../contracts/index.js";
+import type { OperationsAuthorizationResult } from "../contracts/index.js";
+export interface AdminSettingsReadDeps extends BffResponderOptions {
+    settingsPort: Pick<AdminSettingsOperationsPort, "readSettings">;
+    authorizeAdmin: (req: HttpRequest) => Promise<OperationsAuthorizationResult>;
+}
+export interface AdminSettingsUpdateDeps extends BffResponderOptions {
+    settingsPort: Pick<AdminSettingsOperationsPort, "updateSetting">;
+    authorizeAdmin: (req: HttpRequest) => Promise<OperationsAuthorizationResult>;
+}
+export declare function createAdminSettingsReadHandler({ settingsPort, authorizeAdmin, responseRequestId, }: AdminSettingsReadDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export declare function createAdminSettingsUpdateHandler({ settingsPort, authorizeAdmin, responseRequestId, }: AdminSettingsUpdateDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;

package/dist/operations/server/adminSettingsHandlers.js

@@ -0,0 +1,82 @@
+import { createBffResponder } from "../../bff/index.js";
+import { adminSettingsReadRequestSchema, adminSettingsReadResponseSchema, adminSettingsUpdateRequestSchema, adminSettingsUpdateResponseSchema, } from "../index.js";
+export function createAdminSettingsReadHandler({ settingsPort, authorizeAdmin, responseRequestId, }) {
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = createBffResponder({ responseRequestId });
+    return async function handler(req, res) {
+        if (req.method !== "GET") {
+            sendMethodNotAllowed(res, ["GET"]);
+            return;
+        }
+        let authorization;
+        try {
+            authorization = await authorizeAdmin(req);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin authorization failed");
+            return;
+        }
+        if (authorization.ok === false) {
+            sendBffError(res, authorization.code, authorization.message);
+            return;
+        }
+        const request = adminSettingsReadRequestSchema.safeParse(req.query);
+        if (!request.success) {
+            sendBffError(res, "BAD_REQUEST", "Invalid admin settings read request", {
+                details: request.error.flatten(),
+            });
+            return;
+        }
+        try {
+            const result = await settingsPort.readSettings(request.data);
+            const response = adminSettingsReadResponseSchema.safeParse(result);
+            if (!response.success) {
+                sendBffError(res, "INVALID_RESPONSE", "Admin settings read returned invalid response");
+                return;
+            }
+            sendBffSuccess(res, response.data);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin settings read failed");
+        }
+    };
+}
+export function createAdminSettingsUpdateHandler({ settingsPort, authorizeAdmin, responseRequestId, }) {
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = createBffResponder({ responseRequestId });
+    return async function handler(req, res) {
+        if (req.method !== "POST") {
+            sendMethodNotAllowed(res, ["POST"]);
+            return;
+        }
+        let authorization;
+        try {
+            authorization = await authorizeAdmin(req);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin authorization failed");
+            return;
+        }
+        if (authorization.ok === false) {
+            sendBffError(res, authorization.code, authorization.message);
+            return;
+        }
+        const request = adminSettingsUpdateRequestSchema.safeParse(req.body);
+        if (!request.success) {
+            sendBffError(res, "BAD_REQUEST", "Invalid admin settings update request", {
+                details: request.error.flatten(),
+            });
+            return;
+        }
+        try {
+            const result = await settingsPort.updateSetting(request.data);
+            const response = adminSettingsUpdateResponseSchema.safeParse(result);
+            if (!response.success) {
+                sendBffError(res, "INVALID_RESPONSE", "Admin settings update returned invalid response");
+                return;
+            }
+            sendBffSuccess(res, response.data);
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Admin settings update failed");
+        }
+    };
+}

package/dist/operations/server/controlPlaneHandler.d.ts

@@ -0,0 +1,7 @@
+import { type BffResponderOptions } from "../../bff/index.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { PlatformControlPlanePort } from "../contracts/index.js";
+export declare function createPlatformControlPlaneHandler(deps: {
+    port: PlatformControlPlanePort;
+    authorizeAdmin: () => Promise<boolean>;
+} & BffResponderOptions): (req: HttpRequest, res: HttpResponse) => Promise<void>;

package/dist/operations/server/controlPlaneHandler.js

@@ -0,0 +1,54 @@
+import { createBffResponder } from "../../bff/index.js";
+import { platformControlPlaneMutationResponseSchema, platformControlPlaneMutationSchema, platformControlPlaneReadResponseSchema } from "../index.js";
+import { PlatformControlPlaneConflictError } from "../index.js";
+export function createPlatformControlPlaneHandler(deps) {
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = createBffResponder(deps);
+    return async (req, res) => {
+        if (!(await deps.authorizeAdmin())) {
+            sendBffError(res, "UNAUTHORIZED", "Admin session required");
+            return;
+        }
+        try {
+            if (req.method === "GET") {
+                const parsed = platformControlPlaneReadResponseSchema.safeParse(await deps.port.readControlPlane({}));
+                if (!parsed.success)
+                    return invalidResponse(res, sendBffError);
+                sendBffSuccess(res, parsed.data);
+                return;
+            }
+            if (req.method === "POST") {
+                const parsed = platformControlPlaneMutationSchema.safeParse(body(req.body));
+                if (!parsed.success) {
+                    sendBffError(res, "BAD_REQUEST", "Invalid platform control-plane request");
+                    return;
+                }
+                const response = platformControlPlaneMutationResponseSchema.safeParse(await deps.port.mutateControlPlane(parsed.data));
+                if (!response.success)
+                    return invalidResponse(res, sendBffError);
+                sendBffSuccess(res, response.data);
+                return;
+            }
+            sendMethodNotAllowed(res, ["GET", "POST"]);
+        }
+        catch (error) {
+            if (error instanceof PlatformControlPlaneConflictError) {
+                sendBffError(res, "CONFLICT", error.message);
+                return;
+            }
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Platform control plane unavailable");
+        }
+    };
+}
+function body(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function invalidResponse(res, sendBffError) {
+    sendBffError(res, "INVALID_RESPONSE", "Platform control plane returned invalid response");
+}

package/dist/operations/server/controlPlaneStore.d.ts

@@ -0,0 +1,12 @@
+import { type PlatformControlPlanePort } from "../contracts/index.js";
+import type { PgQueryExecutor } from "../../data/index.js";
+export declare const platformControlPlaneSql: {
+    readonly active: string;
+    readonly setControl: string;
+    readonly heartbeat: string;
+    readonly controls: string;
+    readonly jobs: string;
+    readonly alerts: string;
+};
+export declare function createPlatformControlPlanePort(client: PgQueryExecutor, operatorId: string): PlatformControlPlanePort;
+export declare function isPlatformControlOperatorActive(client: PgQueryExecutor, principalId: string): Promise<boolean>;