@spacefast/common 0.0.24 → 0.2.1

package/dist/contracts/superadmin-activity.js

@@ -3,10 +3,8 @@ import { AnyObjectSchema, CursorPaginationSchema } from "./common.js";
 export const superadminActivityListQuerySchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).default(50),
 });
-// Cross-tenant reader over the `activity_events` audit log. Every superadmin
-// mutation appends there, but only tenant-scoped /v1 readers existed; this is
-// the operator's view of the same rows. At least one selective filter is
-// required (see the route) so a query lands on one of the table's indexes
+// Cross-tenant reader over the `activity_events` audit log. At least one
+// selective filter is required (see the route) so a query lands on an index
 // instead of scanning the whole log.
 export const superadminActivityEventQuerySchema = z.object({
     spaceId: z.string().min(1).optional().describe("Filter to events for one Space, cross-tenant."),
@@ -21,7 +19,7 @@ export const superadminActivityEventQuerySchema = z.object({
         .optional()
         .describe("Owning principal id; must be paired with principalType."),
     actorType: z
-        .enum(["user", "api_key", "oauth_client", "anonymous_claim", "system"])
+        .enum(["user", "api_key", "partner_token", "oauth_client", "anonymous_claim", "system"])
         .optional()
         .describe("Actor kind; must be paired with actorId."),
     actorId: z.string().min(1).optional().describe("Actor id; must be paired with actorType."),
@@ -30,8 +28,8 @@ export const superadminActivityEventQuerySchema = z.object({
     limit: z.coerce.number().int().min(1).max(200).default(50),
     cursor: z.string().min(1).optional(),
 });
-// Operator surface: `message` and `details` are the raw audit payloads, not the
-// tenant-facing projection. Nothing here widens any /v1 response.
+// `message` and `details` are the raw audit payloads, not the tenant-facing
+// projection.
 export const SuperadminActivityEventSchema = z.object({
     id: z.string(),
     sequence: z.number().int().nonnegative(),
@@ -57,7 +55,7 @@ export const SuperadminLatestUserSchema = z.object({
     role: z.string().nullable(),
     banned: z.boolean(),
     isAutomattician: z.boolean(),
-    wpcom: z.boolean(),
+    automatticBetaGrant: z.boolean(),
     betaEnrolledAt: z.string().datetime().nullable(),
     createdAt: z.string().datetime(),
     updatedAt: z.string().datetime(),
@@ -67,28 +65,6 @@ export const SuperadminLatestUserSchema = z.object({
 export const SuperadminLatestUserListSchema = z.object({
     users: z.array(SuperadminLatestUserSchema),
 });
-export const SuperadminLatestSpaceSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    slug: z.string(),
-    status: z.string(),
-    tenantId: z.string(),
-    tenantName: z.string().nullable(),
-    teamId: z.string().nullable(),
-    teamSlug: z.string().nullable(),
-    teamName: z.string().nullable(),
-    externalCustomerId: z.string().nullable(),
-    siteId: z.string().nullable(),
-    siteStatus: z.string().nullable(),
-    liveHostname: z.string().nullable(),
-    disabledAt: z.string().datetime().nullable(),
-    deletedAt: z.string().datetime().nullable(),
-    createdAt: z.string().datetime(),
-    updatedAt: z.string().datetime(),
-});
-export const SuperadminLatestSpaceListSchema = z.object({
-    spaces: z.array(SuperadminLatestSpaceSchema),
-});
 export const SuperadminLatestVersionSchema = z.object({
     id: z.string(),
     number: z.number().int().nullable(),

package/dist/contracts/superadmin-emails.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 export declare const superadminEmailStatusValues: readonly ["all", "scheduled", "sent", "suppressed", "delivered", "bounced", "dropped", "complained", "opened", "clicked", "failed"];
 export declare const superadminEmailCategoryValues: readonly ["transactional", "announcements", "offers", "system", "invites"];
+export declare const emailMailboxSchema: z.ZodString;
 export declare const superadminEmailListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;

package/dist/contracts/superadmin-emails.js

@@ -18,6 +18,22 @@ export const superadminEmailStatusValues = [
 // Delivery category is provider-facing telemetry/routing. Recipient control is
 // modeled independently by preferenceTopic; essential auth has no topic.
 export const superadminEmailCategoryValues = emailCategoryValues;
+const bareEmailAddressSchema = z.string().email();
+const namedMailboxPattern = /^(?:"(?:[^"\\\r\n]|\\.)*"|[^<>\r\n]+)\s*<([^<>\r\n]+)>$/;
+// The stored sender is the provider-facing RFC mailbox header, not necessarily
+// a bare addr-spec. Resend accepts both `hello@example.com` and
+// `Spacefast <hello@example.com>`; the operator API must preserve that value.
+export const emailMailboxSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(320)
+    .refine((value) => {
+    if (bareEmailAddressSchema.safeParse(value).success)
+        return true;
+    const address = namedMailboxPattern.exec(value)?.[1]?.trim();
+    return address !== undefined && bareEmailAddressSchema.safeParse(address).success;
+}, "Invalid email mailbox.");
 export const superadminEmailListQuerySchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).default(25),
     offset: z.coerce.number().int().min(0).default(0),
@@ -75,7 +91,7 @@ export const SuperadminEmailSchema = z.object({
     })
         .nullable(),
     to: z.string().email(),
-    from: z.string().email(),
+    from: emailMailboxSchema,
     subject: z.string(),
     text: z.string(),
     html: z.string().nullable(),

package/dist/contracts/superadmin-runtime.d.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+export declare const superadminRuntimeRevisionSchema: z.ZodString;
+export declare const SuperadminRuntimeReleaseSchema: z.ZodObject<{
+    revision: z.ZodString;
+    tag: z.ZodString;
+    zipUrl: z.ZodString;
+    md5: z.ZodString;
+    nativeSha256: z.ZodString;
+    admissionPercent: z.ZodNumber;
+    promotedAt: z.ZodString;
+    current: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const SuperadminRuntimeFleetBoxSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        space: "space";
+        pool: "pool";
+    }>;
+    id: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    title: z.ZodNullable<z.ZodString>;
+    reportedRevision: z.ZodNullable<z.ZodString>;
+    pinnedRevision: z.ZodNullable<z.ZodString>;
+    desiredRevision: z.ZodNullable<z.ZodString>;
+    reportedAt: z.ZodNullable<z.ZodString>;
+    syncState: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        pending: "pending";
+        idle: "idle";
+    }>;
+}, z.core.$strict>;
+export declare const SuperadminRuntimeStatusSchema: z.ZodObject<{
+    checkedAt: z.ZodString;
+    releaseRepo: z.ZodString;
+    latest: z.ZodNullable<z.ZodObject<{
+        revision: z.ZodString;
+        tag: z.ZodString;
+        zipUrl: z.ZodString;
+        md5: z.ZodString;
+        nativeSha256: z.ZodString;
+        admissionPercent: z.ZodNumber;
+        promotedAt: z.ZodString;
+        current: z.ZodBoolean;
+    }, z.core.$strict>>;
+    releases: z.ZodArray<z.ZodObject<{
+        revision: z.ZodString;
+        tag: z.ZodString;
+        zipUrl: z.ZodString;
+        md5: z.ZodString;
+        nativeSha256: z.ZodString;
+        admissionPercent: z.ZodNumber;
+        promotedAt: z.ZodString;
+        current: z.ZodBoolean;
+    }, z.core.$strict>>;
+    available: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        revision: z.ZodString;
+        tag: z.ZodString;
+        publishedAt: z.ZodNullable<z.ZodString>;
+        promoted: z.ZodBoolean;
+        current: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    fleet: z.ZodNullable<z.ZodObject<{
+        spaces: z.ZodObject<{
+            total: z.ZodNumber;
+            current: z.ZodNumber;
+            diverged: z.ZodNumber;
+            pinned: z.ZodNumber;
+        }, z.core.$strip>;
+        pool: z.ZodObject<{
+            total: z.ZodNumber;
+            current: z.ZodNumber;
+            diverged: z.ZodNumber;
+        }, z.core.$strip>;
+        divergedBoxes: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                space: "space";
+                pool: "pool";
+            }>;
+            id: z.ZodString;
+            slug: z.ZodNullable<z.ZodString>;
+            title: z.ZodNullable<z.ZodString>;
+            reportedRevision: z.ZodNullable<z.ZodString>;
+            pinnedRevision: z.ZodNullable<z.ZodString>;
+            desiredRevision: z.ZodNullable<z.ZodString>;
+            reportedAt: z.ZodNullable<z.ZodString>;
+            syncState: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                pending: "pending";
+                idle: "idle";
+            }>;
+        }, z.core.$strict>>;
+        pinnedSpaces: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                space: "space";
+                pool: "pool";
+            }>;
+            id: z.ZodString;
+            slug: z.ZodNullable<z.ZodString>;
+            title: z.ZodNullable<z.ZodString>;
+            reportedRevision: z.ZodNullable<z.ZodString>;
+            pinnedRevision: z.ZodNullable<z.ZodString>;
+            desiredRevision: z.ZodNullable<z.ZodString>;
+            reportedAt: z.ZodNullable<z.ZodString>;
+            syncState: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                pending: "pending";
+                idle: "idle";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const superadminRuntimePreviewBodySchema: z.ZodObject<{
+    revision: z.ZodString;
+}, z.core.$strict>;
+export declare const SuperadminRuntimePreviewActionSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        rollback: "rollback";
+        retry: "retry";
+        promote: "promote";
+    }>;
+    admissionPercent: z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<50>, z.ZodLiteral<100>]>;
+    affected: z.ZodObject<{
+        spaces: z.ZodNumber;
+        pool: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const SuperadminRuntimePreviewSchema: z.ZodObject<{
+    revision: z.ZodString;
+    tag: z.ZodString;
+    zipUrl: z.ZodString;
+    md5: z.ZodString;
+    nativeSha256: z.ZodString;
+    previouslyPromotedAt: z.ZodNullable<z.ZodString>;
+    currentRevision: z.ZodNullable<z.ZodString>;
+    actions: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<{
+            rollback: "rollback";
+            retry: "retry";
+            promote: "promote";
+        }>;
+        admissionPercent: z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<50>, z.ZodLiteral<100>]>;
+        affected: z.ZodObject<{
+            spaces: z.ZodNumber;
+            pool: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const superadminRuntimePromoteBodySchema: z.ZodObject<{
+    revision: z.ZodString;
+    confirmRevision: z.ZodString;
+    action: z.ZodEnum<{
+        rollback: "rollback";
+        retry: "retry";
+        promote: "promote";
+    }>;
+    admissionPercent: z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<50>, z.ZodLiteral<100>]>;
+}, z.core.$strict>;
+export declare const SuperadminRuntimeMutationSchema: z.ZodObject<{
+    revision: z.ZodString;
+    admissionPercent: z.ZodNumber;
+    accepted: z.ZodNumber;
+    queued: z.ZodNumber;
+}, z.core.$strict>;
+export declare const superadminRuntimeAdmissionBodySchema: z.ZodObject<{
+    admissionPercent: z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<50>, z.ZodLiteral<100>]>;
+    confirm: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const superadminRuntimeSyncBodySchema: z.ZodObject<{
+    spaceIds: z.ZodArray<z.ZodString>;
+    action: z.ZodEnum<{
+        pin: "pin";
+        sync: "sync";
+        unpin: "unpin";
+    }>;
+    revision: z.ZodOptional<z.ZodString>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const SuperadminRuntimeSyncResponseSchema: z.ZodObject<{
+    accepted: z.ZodNumber;
+    queued: z.ZodNumber;
+    spaces: z.ZodArray<z.ZodObject<{
+        spaceId: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        desiredRevision: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            pending: "pending";
+            idle: "idle";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SuperadminRuntimeStatus = z.infer<typeof SuperadminRuntimeStatusSchema>;
+export type SuperadminRuntimePreview = z.infer<typeof SuperadminRuntimePreviewSchema>;
+export type SuperadminRuntimePreviewAction = z.infer<typeof SuperadminRuntimePreviewActionSchema>;
+export type SuperadminRuntimeMutation = z.infer<typeof SuperadminRuntimeMutationSchema>;
+export type SuperadminRuntimeSyncResponse = z.infer<typeof SuperadminRuntimeSyncResponseSchema>;

package/dist/contracts/superadmin-runtime.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+export const superadminRuntimeRevisionSchema = z.string().trim().min(1).max(191);
+export const SuperadminRuntimeReleaseSchema = z
+    .object({
+    revision: z.string(),
+    tag: z.string(),
+    zipUrl: z.string(),
+    md5: z.string(),
+    nativeSha256: z.string(),
+    admissionPercent: z.number().int().min(0).max(100),
+    promotedAt: z.string(),
+    current: z.boolean(),
+})
+    .strict();
+export const SuperadminRuntimeFleetBoxSchema = z
+    .object({
+    kind: z.enum(["space", "pool"]),
+    id: z.string(),
+    slug: z.string().nullable(),
+    title: z.string().nullable(),
+    reportedRevision: z.string().nullable(),
+    pinnedRevision: z.string().nullable(),
+    desiredRevision: z.string().nullable(),
+    reportedAt: z.string().datetime().nullable(),
+    syncState: z.enum(["idle", "pending", "running", "failed"]),
+})
+    .strict();
+export const SuperadminRuntimeStatusSchema = z
+    .object({
+    checkedAt: z.string().datetime(),
+    releaseRepo: z.string(),
+    latest: SuperadminRuntimeReleaseSchema.nullable(),
+    releases: z.array(SuperadminRuntimeReleaseSchema),
+    available: z
+        .array(z
+        .object({
+        revision: z.string(),
+        tag: z.string(),
+        publishedAt: z.string().datetime().nullable(),
+        promoted: z.boolean(),
+        current: z.boolean(),
+    })
+        .strict())
+        .nullable(),
+    fleet: z
+        .object({
+        spaces: z.object({
+            total: z.number().int().nonnegative(),
+            current: z.number().int().nonnegative(),
+            diverged: z.number().int().nonnegative(),
+            pinned: z.number().int().nonnegative(),
+        }),
+        pool: z.object({
+            total: z.number().int().nonnegative(),
+            current: z.number().int().nonnegative(),
+            diverged: z.number().int().nonnegative(),
+        }),
+        divergedBoxes: z.array(SuperadminRuntimeFleetBoxSchema),
+        pinnedSpaces: z.array(SuperadminRuntimeFleetBoxSchema),
+    })
+        .nullable(),
+})
+    .strict();
+export const superadminRuntimePreviewBodySchema = z
+    .object({ revision: superadminRuntimeRevisionSchema })
+    .strict();
+export const SuperadminRuntimePreviewActionSchema = z
+    .object({
+    action: z.enum(["promote", "rollback", "retry"]),
+    admissionPercent: z.union([z.literal(10), z.literal(50), z.literal(100)]),
+    affected: z.object({ spaces: z.number().int(), pool: z.number().int() }).strict(),
+})
+    .strict();
+export const SuperadminRuntimePreviewSchema = z
+    .object({
+    revision: z.string(),
+    tag: z.string(),
+    zipUrl: z.string(),
+    md5: z.string(),
+    nativeSha256: z.string(),
+    previouslyPromotedAt: z.string().nullable(),
+    currentRevision: z.string().nullable(),
+    actions: z.array(SuperadminRuntimePreviewActionSchema).min(1),
+})
+    .strict();
+export const superadminRuntimePromoteBodySchema = z
+    .object({
+    revision: superadminRuntimeRevisionSchema,
+    confirmRevision: superadminRuntimeRevisionSchema,
+    action: z.enum(["promote", "rollback", "retry"]),
+    admissionPercent: z.union([z.literal(10), z.literal(50), z.literal(100)]),
+})
+    .strict();
+export const SuperadminRuntimeMutationSchema = z
+    .object({
+    revision: z.string(),
+    admissionPercent: z.number().int().min(0).max(100),
+    accepted: z.number().int().nonnegative(),
+    queued: z.number().int().nonnegative(),
+})
+    .strict();
+export const superadminRuntimeAdmissionBodySchema = z
+    .object({
+    admissionPercent: z.union([z.literal(10), z.literal(50), z.literal(100)]),
+    confirm: z.literal(true),
+})
+    .strict();
+export const superadminRuntimeSyncBodySchema = z
+    .object({
+    spaceIds: z.array(z.string().min(1)).min(1).max(100),
+    action: z.enum(["sync", "pin", "unpin"]),
+    revision: superadminRuntimeRevisionSchema.optional(),
+    force: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.action === "pin" && !value.revision) {
+        context.addIssue({ code: "custom", path: ["revision"], message: "Pin requires a revision." });
+    }
+    if (value.action !== "pin" && value.revision !== undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["revision"],
+            message: "Only pin accepts a revision.",
+        });
+    }
+});
+export const SuperadminRuntimeSyncResponseSchema = z
+    .object({
+    accepted: z.number().int().nonnegative(),
+    queued: z.number().int().nonnegative(),
+    spaces: z.array(z
+        .object({
+        spaceId: z.string(),
+        targetRevision: z.string().nullable(),
+        desiredRevision: z.string().nullable(),
+        state: z.enum(["idle", "pending", "running", "failed"]),
+    })
+        .strict()),
+})
+    .strict();

package/dist/contracts/superadmin-search.d.ts

@@ -9,10 +9,10 @@ export declare const SuperadminSearchHitSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     teamSlug: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
         active: "active";
+        failed: "failed";
         provisioning: "provisioning";
         updating: "updating";
         deleting: "deleting";
-        failed: "failed";
     }>;
     anonymous: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
@@ -46,15 +46,25 @@ export declare const SuperadminSearchHitSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         ready_pool: "ready_pool";
         degraded: "degraded";
         retired: "retired";
+        cleanup_pending: "cleanup_pending";
     }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"operation">;
+    id: z.ZodString;
+    eventType: z.ZodString;
+    status: z.ZodString;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"hostname">;
     hostname: z.ZodString;
     spaceId: z.ZodString;
     matchedBy: z.ZodEnum<{
         domain: "domain";
+        retired: "retired";
         hostname: "hostname";
         derived: "derived";
+        retained: "retained";
     }>;
 }, z.core.$strip>], "kind">;
 export declare const SuperadminSearchResultSchema: z.ZodObject<{
@@ -69,10 +79,10 @@ export declare const SuperadminSearchResultSchema: z.ZodObject<{
         teamSlug: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
             active: "active";
+            failed: "failed";
             provisioning: "provisioning";
             updating: "updating";
             deleting: "deleting";
-            failed: "failed";
         }>;
         anonymous: z.ZodBoolean;
     }, z.core.$strip>, z.ZodObject<{
@@ -106,15 +116,25 @@ export declare const SuperadminSearchResultSchema: z.ZodObject<{
             ready_pool: "ready_pool";
             degraded: "degraded";
             retired: "retired";
+            cleanup_pending: "cleanup_pending";
         }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"operation">;
+        id: z.ZodString;
+        eventType: z.ZodString;
+        status: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"hostname">;
         hostname: z.ZodString;
         spaceId: z.ZodString;
         matchedBy: z.ZodEnum<{
             domain: "domain";
+            retired: "retired";
             hostname: "hostname";
             derived: "derived";
+            retained: "retained";
         }>;
     }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;

package/dist/contracts/superadmin-search.js

@@ -1,9 +1,7 @@
 import { z } from "zod";
 import { poolSiteStatus, spaceStatus, tenantStatus } from "./enums.js";
-// The operator omnibox. One query string, every operator-visible identity:
-// spaces, teams, users, tenants, provider sites, and any hostname Spacefast
-// serves. Each hit carries just enough to render a row and route to the
-// resource — the detail routes own the rest.
+// The operator omnibox: one query string over every operator-visible identity.
+// Each hit carries just enough to render a row and route to the resource.
 export const SuperadminSearchHitSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("space"),
@@ -42,13 +40,23 @@ export const SuperadminSearchHitSchema = z.discriminatedUnion("kind", [
         primaryHostname: z.string(),
         status: poolSiteStatus,
     }),
+    z.object({
+        kind: z.literal("operation"),
+        id: z.string(),
+        eventType: z.string(),
+        status: z.string(),
+        resourceType: z.string(),
+        resourceId: z.string(),
+    }),
     // A served hostname resolved to its space: default hostname, custom domain,
-    // version host, or branch alias. `matchedBy` says which of those matched.
+    // version host, or branch alias.
     z.object({
         kind: z.literal("hostname"),
         hostname: z.string(),
         spaceId: z.string(),
-        matchedBy: z.enum(["domain", "hostname", "derived"]),
+        // Mirrors the resolver's full match set (superadmin/investigate.ts):
+        // retained/retired hostnames are real lookup outcomes, not errors.
+        matchedBy: z.enum(["domain", "hostname", "derived", "retained", "retired"]),
     }),
 ]);
 export const SuperadminSearchResultSchema = z.object({