@builder.io/ai-utils 0.82.0 → 0.83.0-dev.202607211718.99c5f9cf8

package/src/projects.d.ts

@@ -153,7 +153,7 @@ export interface ReadyMessage extends BaseMessage {
 }
 export type MachineState = "unknown" | "created" | "starting" | "started" | "stopping" | "stopped" | "suspending" | "suspended" | "replacing" | "destroying" | "destroyed" | "not-found" | "running" | "failed";
 export type FlyVolumeState = "unknown" | "creating" | "created" | "extending" | "restoring" | "enabling_remote_export" | "hydrating" | "recovering" | "scheduling_destroy" | "pending_destroy" | "failed";
-export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable";
+export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable" | "git-auth-reauth-required";
 /**
  * Git provider types for diagnostics.
  */
@@ -1489,9 +1489,8 @@ export declare const ProjectHostingSchema: z.ZodObject<{
         uploading: "uploading";
     }>>;
     publishedCommit: z.ZodOptional<z.ZodString>;
-    customDomain: z.ZodOptional<z.ZodString>;
-    customDomainVerified: z.ZodOptional<z.ZodBoolean>;
     autoDeploy: z.ZodOptional<z.ZodBoolean>;
+    domainIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ProjectHosting = z.infer<typeof ProjectHostingSchema>;
 /**
@@ -1710,6 +1709,113 @@ export declare const GetDeploysResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type GetDeploysResponse = z.infer<typeof GetDeploysResponseSchema>;
+export declare const HostingDomainStatusSchema: z.ZodEnum<{
+    active: "active";
+    failed: "failed";
+    pending: "pending";
+    provisioning: "provisioning";
+    verifying: "verifying";
+}>;
+export type HostingDomainStatus = z.infer<typeof HostingDomainStatusSchema>;
+export declare const HostingDomainKindSchema: z.ZodEnum<{
+    apex: "apex";
+    subdomain: "subdomain";
+}>;
+export type HostingDomainKind = z.infer<typeof HostingDomainKindSchema>;
+/**
+ * Custom domain record, stored at `hosting-domains/{domain}`.
+ * The normalized domain is the doc key — global uniqueness comes for free.
+ * This doc is both the record AND the claim for the domain.
+ */
+export declare const HostingDomainSchema: z.ZodObject<{
+    domain: z.ZodString;
+    kind: z.ZodEnum<{
+        apex: "apex";
+        subdomain: "subdomain";
+    }>;
+    projectId: z.ZodString;
+    ownerId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+        provisioning: "provisioning";
+        verifying: "verifying";
+    }>;
+    dnsAuthId: z.ZodString;
+    delegationTarget: z.ZodString;
+    trafficTarget: z.ZodOptional<z.ZodString>;
+    certId: z.ZodOptional<z.ZodString>;
+    certMapEntryName: z.ZodOptional<z.ZodString>;
+    httpRouteName: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    pendingSince: z.ZodNumber;
+    verifyingSince: z.ZodOptional<z.ZodNumber>;
+    attemptId: z.ZodOptional<z.ZodString>;
+    verifiedAt: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    failedStep: z.ZodOptional<z.ZodEnum<{
+        dns: "dns";
+        https: "https";
+    }>>;
+    createdBy: z.ZodString;
+}, z.core.$strip>;
+export type HostingDomain = z.infer<typeof HostingDomainSchema>;
+export declare const AddDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type AddDomainRequest = z.infer<typeof AddDomainRequestSchema>;
+export declare const AddDomainResponseSchema: z.ZodObject<{
+    domain: z.ZodString;
+    kind: z.ZodEnum<{
+        apex: "apex";
+        subdomain: "subdomain";
+    }>;
+    records: z.ZodObject<{
+        traffic: z.ZodObject<{
+            recordType: z.ZodEnum<{
+                A: "A";
+                CNAME: "CNAME";
+            }>;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>;
+        validation: z.ZodObject<{
+            recordType: z.ZodEnum<{
+                A: "A";
+                CNAME: "CNAME";
+            }>;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AddDomainResponse = z.infer<typeof AddDomainResponseSchema>;
+export declare const VerifyDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type VerifyDomainRequest = z.infer<typeof VerifyDomainRequestSchema>;
+export declare const VerifyDomainResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+        provisioning: "provisioning";
+        verifying: "verifying";
+    }>;
+}, z.core.$strip>;
+export type VerifyDomainResponse = z.infer<typeof VerifyDomainResponseSchema>;
+export declare const RemoveDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type RemoveDomainRequest = z.infer<typeof RemoveDomainRequestSchema>;
+export declare const RemoveDomainResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RemoveDomainResponse = z.infer<typeof RemoveDomainResponseSchema>;
 export declare const CloneProjectOptionsSchema: z.ZodObject<{
     sourceProjectId: z.ZodString;
     sourceBranchName: z.ZodDefault<z.ZodString>;

package/src/projects.js

@@ -322,12 +322,13 @@ export const ProjectHostingSchema = z.object({
     lastDeployStatus: DeployStatusSchema.optional(),
     /** Git commit currently live at the project's hosting URL (set on go-live). */
     publishedCommit: z.string().optional(),
-    customDomain: z.string().optional(),
-    customDomainVerified: z.boolean().optional(),
     autoDeploy: z
         .boolean()
         .optional()
         .meta({ description: "auto-deploy on push/merge" }),
+    domainIds: z.array(z.string()).optional().meta({
+        description: "Doc keys (normalized domains) in `hosting-domains` attached to this project. The domain docs are the source of truth; this is only the back-pointer.",
+    }),
 });
 /**
  * Canonical "is this project hostable" predicate. Keys off the explicit
@@ -613,6 +614,90 @@ export const GetDeploysRequestSchema = z.object({
 export const GetDeploysResponseSchema = z.object({
     deploys: z.array(DeployListItemSchema),
 });
+export const HostingDomainStatusSchema = z.enum([
+    "pending",
+    "verifying",
+    "provisioning",
+    "active",
+    "failed",
+]);
+export const HostingDomainKindSchema = z.enum(["apex", "subdomain"]);
+/**
+ * Custom domain record, stored at `hosting-domains/{domain}`.
+ * The normalized domain is the doc key — global uniqueness comes for free.
+ * This doc is both the record AND the claim for the domain.
+ */
+export const HostingDomainSchema = z.object({
+    domain: z
+        .string()
+        .meta({ description: "Doc key — normalized (punycode) domain." }),
+    kind: HostingDomainKindSchema,
+    projectId: z.string(),
+    ownerId: z.string(),
+    status: HostingDomainStatusSchema,
+    dnsAuthId: z
+        .string()
+        .meta({ description: "GCP DNS authorization resource name." }),
+    delegationTarget: z.string().meta({
+        description: "_acme-challenge CNAME value the customer must add.",
+    }),
+    trafficTarget: z.string().optional().meta({
+        description: "The traffic record value: ALB anycast IP for apex domains, `cname.builder.cloud` for subdomains. Persisted so the UI can reconstruct both DNS records after page reload.",
+    }),
+    certId: z
+        .string()
+        .optional()
+        .meta({ description: "Certificate Manager cert resource name." }),
+    certMapEntryName: z.string().optional(),
+    httpRouteName: z.string().optional(),
+    createdAt: z.number(),
+    pendingSince: z.number().meta({
+        description: "TTL anchor: set on entering `pending`, re-stamped on `failed`→`pending`.",
+    }),
+    verifyingSince: z.number().optional().meta({
+        description: "Set when the delegation-check poll loop starts (on entering `verifying`). Used for the poll timeout and UI. Cleared on promotion to `provisioning` or on failure.",
+    }),
+    attemptId: z.string().optional().meta({
+        description: "Per-verify-attempt nonce, set on entering `verifying`. Delegation-check polls whose attemptId no longer matches are stale (a newer retry superseded them) and stop early.",
+    }),
+    verifiedAt: z.number().optional(),
+    error: z.string().optional(),
+    failedStep: z.enum(["dns", "https"]).optional().meta({
+        description: "Which setup step failed, set alongside `status: failed` so the UI can attribute the failure. `dns` = delegation verification, `https` = cert/route provisioning.",
+    }),
+    createdBy: z.string(),
+});
+export const AddDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+const DnsRecordSchema = z.object({
+    recordType: z.enum(["A", "CNAME"]),
+    name: z.string(),
+    value: z.string(),
+});
+export const AddDomainResponseSchema = z.object({
+    domain: z.string(),
+    kind: HostingDomainKindSchema,
+    records: z.object({
+        traffic: DnsRecordSchema,
+        validation: DnsRecordSchema,
+    }),
+});
+export const VerifyDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+export const VerifyDomainResponseSchema = z.object({
+    status: HostingDomainStatusSchema,
+});
+export const RemoveDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+export const RemoveDomainResponseSchema = z.object({
+    success: z.literal(true),
+});
 export const CloneProjectOptionsSchema = z.object({
     sourceProjectId: z.string().min(1).meta({
         description: "Project to clone from.",

package/src/vpc-peering.d.ts

@@ -0,0 +1,49 @@
+/** Fields common to all VPC connectivity types. */
+interface VpcConnectionBase {
+    id: string;
+    ownerId: string;
+    type: string;
+    gcpRegion: string;
+    customerDnsServers: string[];
+    proxyIp: string;
+    enabled: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Traditional VPC Peering via bridge VPC. */
+export interface VpcGcpPeering extends VpcConnectionBase {
+    type: "gcp-peering";
+    gcpProjectId: string;
+    gcpNetworkName: string;
+    bridgeCidr: string;
+    importCustomRoutes: boolean;
+}
+/**
+ * PSC Network Attachment — customer creates the network attachment in their VPC,
+ * our proxy VM connects to it via a PSC interface on nic1.
+ * No bridge VPC or bridge CIDR needed on our side.
+ */
+export interface VpcGcpNetworkAttachment extends VpcConnectionBase {
+    type: "gcp-network-attachment";
+    gcpProjectId: string;
+    networkAttachmentName: string;
+}
+/** Discriminated union of all VPC connectivity types. */
+export type VpcPeering = VpcGcpPeering | VpcGcpNetworkAttachment;
+export interface CreateVpcGcpPeeringParams {
+    type: "gcp-peering";
+    gcpRegion: string;
+    gcpProjectId: string;
+    gcpNetworkName: string;
+    bridgeCidr: string;
+    customerDnsServers: string[];
+    importCustomRoutes?: boolean;
+}
+export interface CreateVpcGcpNetworkAttachmentParams {
+    type: "gcp-network-attachment";
+    gcpProjectId: string;
+    networkAttachmentName: string;
+    customerDnsServers: string[];
+}
+export type CreateVpcPeeringParams = CreateVpcGcpPeeringParams | CreateVpcGcpNetworkAttachmentParams;
+export {};

package/src/vpc-peering.js

@@ -0,0 +1 @@
+export {};