@appforge-ci/core 0.2.3 → 0.3.0

package/dist/build-vpn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-vpn.js","sourceRoot":"","sources":["../src/build-vpn.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAA+B;IAC9D,IAAI,CAAC,GAAG;QAAE,OAAO,0BAA0B,CAAC;IAC5C,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,IAAI,QAAQ,CAAC;IACxC,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;QACb,IAAI,GAAG,CAAC,OAAO,KAAK,WAAW;YAAE,OAAO,qBAAqB,IAAI,cAAc,CAAC;QAChF,IAAI,GAAG,CAAC,OAAO,KAAK,QAAQ;YAAE,OAAO,sBAAsB,GAAG,CAAC,MAAM,IAAI,gCAAgC,EAAE,CAAC;QAC5G,OAAO,kBAAkB,IAAI,oCAAoC,CAAC;IACpE,CAAC;IACD,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS;QAAE,OAAO,gEAAgE,CAAC;IACvG,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/index.d.ts

@@ -6,5 +6,10 @@ export * from "./ota-rollout.js";
 export * from "./ota-bundle-hash.js";
 export * from "./ota-artifact.js";
 export * from "./vpn-network.js";
+export * from "./vpn-egress.js";
+export * from "./vpn-ssh.js";
+export * from "./vpn-egress-presets.js";
 export * from "./artifact-upload.js";
+export * from "./build-vpn.js";
+export * from "./attestation.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -6,5 +6,10 @@ export * from "./ota-rollout.js";
 export * from "./ota-bundle-hash.js";
 export * from "./ota-artifact.js";
 export * from "./vpn-network.js";
+export * from "./vpn-egress.js";
+export * from "./vpn-ssh.js";
+export * from "./vpn-egress-presets.js";
 export * from "./artifact-upload.js";
+export * from "./build-vpn.js";
+export * from "./attestation.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dist/schemas.d.ts

@@ -492,14 +492,14 @@ export declare const updateAppSchema: z.ZodObject<{
     useVpn: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
+    useVpn?: boolean | undefined;
     repoUrl?: string | undefined;
     defaultBranch?: string | undefined;
-    useVpn?: boolean | undefined;
 }, {
     name?: string | undefined;
+    useVpn?: boolean | undefined;
     repoUrl?: string | undefined;
     defaultBranch?: string | undefined;
-    useVpn?: boolean | undefined;
 }>;
 export declare const updateOrgSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -629,6 +629,20 @@ export declare const agentHeartbeatSchema: z.ZodObject<{
      *  predates the VPN feature omits it and stays `vpnCapable = 0`, so it
      *  is never offered a VPN build. */
     vpnCapable: z.ZodOptional<z.ZodBoolean>;
+    /** VPN features this agent can enforce (migrations/0043) — ids matching
+     *  `VPN_FEATURE_ID_PATTERN`, at most `MAX_VPN_FEATURES`. Like `vpnCapable`
+     *  the stored value is derived from THIS heartbeat alone: omitting it (an
+     *  older agent) means "no features", never "keep the last value". A
+     *  malformed list is rejected (400) rather than half-trusted. */
+    vpnFeatures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Build-isolation level this agent enforces (migrations/0043). Same
+     *  omit-means-default (`none`) rule as `vpnFeatures`. */
+    enforcementLevel: z.ZodOptional<z.ZodEnum<["none", "sandbox", "sandbox_uid"]>>;
+    /** Whether a GitHub Actions self-hosted runner shares this machine
+     *  (migrations/0047). Like `vpnFeatures`, stored from THIS heartbeat alone:
+     *  omitted (an older agent, or a check that failed) means "unknown", never
+     *  "keep the last value", and unknown refuses a dedicated host. */
+    coHostedRunner: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     status: "online" | "draining" | "building";
     xcodeVersion: string | null;
@@ -642,6 +656,9 @@ export declare const agentHeartbeatSchema: z.ZodObject<{
     agentVersion?: string | null | undefined;
     screenSharingEnabled?: boolean | null | undefined;
     vpnCapable?: boolean | undefined;
+    vpnFeatures?: string[] | undefined;
+    enforcementLevel?: "none" | "sandbox" | "sandbox_uid" | undefined;
+    coHostedRunner?: boolean | undefined;
     tailscaleHostname?: string | null | undefined;
     currentBuildId?: string | null | undefined;
     activeBuildIds?: string[] | undefined;
@@ -659,6 +676,9 @@ export declare const agentHeartbeatSchema: z.ZodObject<{
     agentVersion?: string | null | undefined;
     screenSharingEnabled?: boolean | null | undefined;
     vpnCapable?: boolean | undefined;
+    vpnFeatures?: string[] | undefined;
+    enforcementLevel?: "none" | "sandbox" | "sandbox_uid" | undefined;
+    coHostedRunner?: boolean | undefined;
     tailscaleHostname?: string | null | undefined;
     currentBuildId?: string | null | undefined;
     activeBuildIds?: string[] | undefined;
@@ -668,11 +688,11 @@ export declare const appendLogSchema: z.ZodObject<{
     chunk: z.ZodString;
     seq: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    chunk: string;
     seq: number;
-}, {
     chunk: string;
+}, {
     seq: number;
+    chunk: string;
 }>;
 export declare const completeBuildSchema: z.ZodObject<{
     status: z.ZodEnum<["succeeded", "failed"]>;
@@ -737,8 +757,8 @@ export declare const promoteOtaReleaseSchema: z.ZodObject<{
     rollout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     channel: string;
-    mandatory: boolean;
     buildId: string;
+    mandatory: boolean;
     rollout: number;
 }, {
     buildId: string;
@@ -785,6 +805,29 @@ export declare const setAgentVpnApprovedSchema: z.ZodObject<{
 }, {
     approved: boolean;
 }>;
+/** `PATCH /orgs/:orgId/agents/:agentId/dedicated` (apps/admin-api) — the
+ *  only way `Agent.dedicatedOrgId` ever changes (migrations/0043). An
+ *  operator taint, deliberately not in agentHeartbeatSchema/agentEnrollSchema:
+ *  an agent must never be able to widen or lift its own restriction. `null`
+ *  clears it (the Mac goes back to being shared). */
+export declare const setAgentDedicatedOrgSchema: z.ZodObject<{
+    dedicatedOrgId: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dedicatedOrgId: string | null;
+}, {
+    dedicatedOrgId: string | null;
+}>;
+/** `PATCH /orgs/:orgId/vpn-hosts/:tunnelOrgId/policy` (apps/admin-api, platform
+ *  admins only) — the only way `VpnTunnel.hostPolicy` ever changes
+ *  (migrations/0047). Deliberately not in `updateVpnTunnelSchema`: an org
+ *  admin must not be able to loosen the placement the operator set. */
+export declare const setVpnHostPolicySchema: z.ZodObject<{
+    hostPolicy: z.ZodEnum<["shared", "pinned", "dedicated"]>;
+}, "strip", z.ZodTypeAny, {
+    hostPolicy: "shared" | "pinned" | "dedicated";
+}, {
+    hostPolicy: "shared" | "pinned" | "dedicated";
+}>;
 /** `PATCH /orgs/:orgId/agents/:agentId/device-stream-hostname` (apps/
  *  admin-api)'s request body — `hostname: null` clears it, going back
  *  to the global DEVICE_STREAM_WS_URL fallback (see migrations/0034's
@@ -812,7 +855,159 @@ export declare const startVncSessionSchema: z.ZodObject<{
 }, {
     mode?: "view" | "control" | undefined;
 }>;
-export declare const createVpnTunnelSchema: z.ZodObject<{
+/**
+ * The shape-only form of the create/update bodies, WITHOUT the egress rules. The
+ * API route parses with these and then runs `resolveEgressChange`, which applies
+ * the same `validateEgressSettings` but answers with a structured 400 listing
+ * every problem (`errors`) rather than a generic schema error. Anything else
+ * should use `createVpnTunnelSchema` / `updateVpnTunnelSchema` below.
+ */
+export declare const createVpnTunnelBodySchema: z.ZodObject<{
+    /** `regulated` needs `strictEgress`, and the operator's REGULATED_VPN_ENABLED flag. */
+    complianceMode: z.ZodOptional<z.ZodEnum<["standard", "regulated"]>>;
+    strictEgress: z.ZodOptional<z.ZodBoolean>;
+    /** Preset ids; replaces the list. */
+    egressPresets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Custom hosts (exact or `*.suffix`, port 443 unless `ports` says otherwise); replaces the list. */
+    egressAllow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        ports: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        ports?: number[] | undefined;
+    }, {
+        host: string;
+        ports?: number[] | undefined;
+    }>, "many">>;
+    name: z.ZodString;
+    gatewayEndpoint: z.ZodString;
+    gatewayPublicKey: z.ZodString;
+    lanCidrs: z.ZodArray<z.ZodString, "many">;
+    dnsServer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Omit to have the server allocate a free /30. Supply it only when a
+     *  customer network already routes the allocated range. */
+    tunnelCidr: z.ZodOptional<z.ZodString>;
+    /** Lab mode — allow a private (RFC1918/CGNAT) gateway endpoint. Setting it
+     *  `true` is platform-admin only (enforced by the route, not here). */
+    allowPrivateEndpoint: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    gatewayEndpoint: string;
+    gatewayPublicKey: string;
+    lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}, {
+    name: string;
+    gatewayEndpoint: string;
+    gatewayPublicKey: string;
+    lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}>;
+export declare const updateVpnTunnelBodySchema: z.ZodObject<{
+    /** `regulated` needs `strictEgress`, and the operator's REGULATED_VPN_ENABLED flag. */
+    complianceMode: z.ZodOptional<z.ZodEnum<["standard", "regulated"]>>;
+    strictEgress: z.ZodOptional<z.ZodBoolean>;
+    /** Preset ids; replaces the list. */
+    egressPresets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Custom hosts (exact or `*.suffix`, port 443 unless `ports` says otherwise); replaces the list. */
+    egressAllow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        ports: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        ports?: number[] | undefined;
+    }, {
+        host: string;
+        ports?: number[] | undefined;
+    }>, "many">>;
+    name: z.ZodOptional<z.ZodString>;
+    gatewayEndpoint: z.ZodOptional<z.ZodString>;
+    gatewayPublicKey: z.ZodOptional<z.ZodString>;
+    lanCidrs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Explicit `null` clears it; omitted leaves it unchanged. */
+    dnsServer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tunnelCidr: z.ZodOptional<z.ZodString>;
+    /** Lab mode. `true` is platform-admin only; omitted leaves it unchanged. */
+    allowPrivateEndpoint: z.ZodOptional<z.ZodBoolean>;
+    /** `false` disables the tunnel (builds that need it then fail fast
+     *  instead of queueing); `true` re-enables it, back to `pending` until
+     *  the next handshake proves it works. */
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    enabled?: boolean | undefined;
+    gatewayEndpoint?: string | undefined;
+    gatewayPublicKey?: string | undefined;
+    lanCidrs?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    enabled?: boolean | undefined;
+    gatewayEndpoint?: string | undefined;
+    gatewayPublicKey?: string | undefined;
+    lanCidrs?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}>;
+/** The create body, with the egress rules (bare `*`, IP literals, unknown presets, merged port limit) enforced too. */
+export declare const createVpnTunnelSchema: z.ZodEffects<z.ZodObject<{
+    /** `regulated` needs `strictEgress`, and the operator's REGULATED_VPN_ENABLED flag. */
+    complianceMode: z.ZodOptional<z.ZodEnum<["standard", "regulated"]>>;
+    strictEgress: z.ZodOptional<z.ZodBoolean>;
+    /** Preset ids; replaces the list. */
+    egressPresets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Custom hosts (exact or `*.suffix`, port 443 unless `ports` says otherwise); replaces the list. */
+    egressAllow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        ports: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        ports?: number[] | undefined;
+    }, {
+        host: string;
+        ports?: number[] | undefined;
+    }>, "many">>;
     name: z.ZodString;
     gatewayEndpoint: z.ZodString;
     gatewayPublicKey: z.ZodString;
@@ -830,21 +1025,84 @@ export declare const createVpnTunnelSchema: z.ZodObject<{
     gatewayEndpoint: string;
     gatewayPublicKey: string;
     lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
     dnsServer?: string | null | undefined;
     allowedDomains?: string[] | undefined;
     tunnelCidr?: string | undefined;
     allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
 }, {
     name: string;
     gatewayEndpoint: string;
     gatewayPublicKey: string;
     lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
     dnsServer?: string | null | undefined;
     allowedDomains?: string[] | undefined;
     tunnelCidr?: string | undefined;
     allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}>, {
+    name: string;
+    gatewayEndpoint: string;
+    gatewayPublicKey: string;
+    lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}, {
+    name: string;
+    gatewayEndpoint: string;
+    gatewayPublicKey: string;
+    lanCidrs: string[];
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
 }>;
-export declare const updateVpnTunnelSchema: z.ZodObject<{
+/** The update body, with the egress rules enforced too. */
+export declare const updateVpnTunnelSchema: z.ZodEffects<z.ZodObject<{
+    /** `regulated` needs `strictEgress`, and the operator's REGULATED_VPN_ENABLED flag. */
+    complianceMode: z.ZodOptional<z.ZodEnum<["standard", "regulated"]>>;
+    strictEgress: z.ZodOptional<z.ZodBoolean>;
+    /** Preset ids; replaces the list. */
+    egressPresets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Custom hosts (exact or `*.suffix`, port 443 unless `ports` says otherwise); replaces the list. */
+    egressAllow: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        ports: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        ports?: number[] | undefined;
+    }, {
+        host: string;
+        ports?: number[] | undefined;
+    }>, "many">>;
     name: z.ZodOptional<z.ZodString>;
     gatewayEndpoint: z.ZodOptional<z.ZodString>;
     gatewayPublicKey: z.ZodOptional<z.ZodString>;
@@ -861,6 +1119,11 @@ export declare const updateVpnTunnelSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
     enabled?: boolean | undefined;
     gatewayEndpoint?: string | undefined;
     gatewayPublicKey?: string | undefined;
@@ -869,8 +1132,15 @@ export declare const updateVpnTunnelSchema: z.ZodObject<{
     allowedDomains?: string[] | undefined;
     tunnelCidr?: string | undefined;
     allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
 }, {
     name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
     enabled?: boolean | undefined;
     gatewayEndpoint?: string | undefined;
     gatewayPublicKey?: string | undefined;
@@ -879,6 +1149,71 @@ export declare const updateVpnTunnelSchema: z.ZodObject<{
     allowedDomains?: string[] | undefined;
     tunnelCidr?: string | undefined;
     allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}>, {
+    name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    enabled?: boolean | undefined;
+    gatewayEndpoint?: string | undefined;
+    gatewayPublicKey?: string | undefined;
+    lanCidrs?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    egressAllow?: {
+        host: string;
+        ports?: number[] | undefined;
+    }[] | undefined;
+    egressPresets?: string[] | undefined;
+    enabled?: boolean | undefined;
+    gatewayEndpoint?: string | undefined;
+    gatewayPublicKey?: string | undefined;
+    lanCidrs?: string[] | undefined;
+    dnsServer?: string | null | undefined;
+    allowedDomains?: string[] | undefined;
+    tunnelCidr?: string | undefined;
+    allowPrivateEndpoint?: boolean | undefined;
+    complianceMode?: "standard" | "regulated" | undefined;
+    strictEgress?: boolean | undefined;
+}>;
+/**
+ * The strict-egress allow-list (`VpnJobConfig.egress`; docs in vpn-egress.ts).
+ * Field-level shape and size bounds only; the host rules (no IP literals, no
+ * bare `*`, no trailing dot ...) live in `validateVpnEgressPolicy` so the
+ * server, the CLI and the agent apply the identical checks and report every
+ * problem at once. Tunnel settings (PR-D) will embed this.
+ */
+export declare const vpnEgressPolicySchema: z.ZodObject<{
+    allow: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        ports: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        ports?: number[] | undefined;
+    }, {
+        host: string;
+        ports?: number[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    allow: {
+        host: string;
+        ports?: number[] | undefined;
+    }[];
+}, {
+    allow: {
+        host: string;
+        ports?: number[] | undefined;
+    }[];
 }>;
 /** `POST /agents/vpn/report` (apps/admin-api) — what the agent that holds
  *  an org's tunnel for a build tells the control plane about it. The

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"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"}

package/dist/schemas.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { ENFORCEMENT_LEVELS, MAX_VPN_FEATURES, VPN_FEATURE_ID_PATTERN, VPN_HOST_POLICIES } from "./agent-readiness.js";
+import { VPN_COMPLIANCE_MODES, VPN_EGRESS_MAX_CUSTOM_RULES, VPN_EGRESS_MAX_PRESETS, validateEgressSettings } from "./vpn-egress-presets.js";
 export const platformSchema = z.enum(["ios", "android", "flutter", "react-native"]);
 export const appforgeWorkflowSchema = z.object({
     name: z.string().optional(),
@@ -456,6 +458,20 @@ export const agentHeartbeatSchema = z.object({
      *  predates the VPN feature omits it and stays `vpnCapable = 0`, so it
      *  is never offered a VPN build. */
     vpnCapable: z.boolean().optional(),
+    /** VPN features this agent can enforce (migrations/0043) — ids matching
+     *  `VPN_FEATURE_ID_PATTERN`, at most `MAX_VPN_FEATURES`. Like `vpnCapable`
+     *  the stored value is derived from THIS heartbeat alone: omitting it (an
+     *  older agent) means "no features", never "keep the last value". A
+     *  malformed list is rejected (400) rather than half-trusted. */
+    vpnFeatures: z.array(z.string().regex(VPN_FEATURE_ID_PATTERN)).max(MAX_VPN_FEATURES).optional(),
+    /** Build-isolation level this agent enforces (migrations/0043). Same
+     *  omit-means-default (`none`) rule as `vpnFeatures`. */
+    enforcementLevel: z.enum(ENFORCEMENT_LEVELS).optional(),
+    /** Whether a GitHub Actions self-hosted runner shares this machine
+     *  (migrations/0047). Like `vpnFeatures`, stored from THIS heartbeat alone:
+     *  omitted (an older agent, or a check that failed) means "unknown", never
+     *  "keep the last value", and unknown refuses a dedicated host. */
+    coHostedRunner: z.boolean().optional(),
 });
 // `POST /builds/:buildId/logs` (apps/admin-api/src/routes/agents.ts) —
 // one call per flushed line/burst from `packages/agent/src/lib/
@@ -543,6 +559,21 @@ export const setAgentRemoteControlSchema = z.object({
 export const setAgentVpnApprovedSchema = z.object({
     approved: z.boolean(),
 });
+/** `PATCH /orgs/:orgId/agents/:agentId/dedicated` (apps/admin-api) — the
+ *  only way `Agent.dedicatedOrgId` ever changes (migrations/0043). An
+ *  operator taint, deliberately not in agentHeartbeatSchema/agentEnrollSchema:
+ *  an agent must never be able to widen or lift its own restriction. `null`
+ *  clears it (the Mac goes back to being shared). */
+export const setAgentDedicatedOrgSchema = z.object({
+    dedicatedOrgId: z.string().min(1).max(128).nullable(),
+});
+/** `PATCH /orgs/:orgId/vpn-hosts/:tunnelOrgId/policy` (apps/admin-api, platform
+ *  admins only) — the only way `VpnTunnel.hostPolicy` ever changes
+ *  (migrations/0047). Deliberately not in `updateVpnTunnelSchema`: an org
+ *  admin must not be able to loosen the placement the operator set. */
+export const setVpnHostPolicySchema = z.object({
+    hostPolicy: z.enum(VPN_HOST_POLICIES),
+});
 /** `PATCH /orgs/:orgId/agents/:agentId/device-stream-hostname` (apps/
  *  admin-api)'s request body — `hostname: null` clears it, going back
  *  to the global DEVICE_STREAM_WS_URL fallback (see migrations/0034's
@@ -569,7 +600,45 @@ export const startVncSessionSchema = z.object({
 // and the route all apply the identical checks, with every problem
 // reported at once.
 const vpnNameSchema = z.string().min(1).max(64, "must be at most 64 characters");
-export const createVpnTunnelSchema = z.object({
+/**
+ * The egress-policy fields of a tunnel (migrations/0045), shared by create and
+ * update. The field shapes here are shape and size bounds only; which preset ids
+ * exist and which hosts are acceptable (no bare `*`, no IP literals ...) is
+ * `validateEgressSettings` (vpn-egress-presets.ts), which `refineVpnEgressSettings`
+ * applies on top so a caller that relies on these schemas alone cannot accept
+ * what the route would refuse. Whether `regulated` may be set at all is the
+ * route's call (an operator flag), not the schema's.
+ */
+const vpnEgressSettingsFields = {
+    /** `regulated` needs `strictEgress`, and the operator's REGULATED_VPN_ENABLED flag. */
+    complianceMode: z.enum(VPN_COMPLIANCE_MODES).optional(),
+    strictEgress: z.boolean().optional(),
+    /** Preset ids; replaces the list. */
+    egressPresets: z.array(z.string().min(1).max(64)).max(VPN_EGRESS_MAX_PRESETS).optional(),
+    /** Custom hosts (exact or `*.suffix`, port 443 unless `ports` says otherwise); replaces the list. */
+    egressAllow: z
+        .array(z.object({
+        host: z.string().min(1).max(253),
+        ports: z.array(z.number().int().min(1).max(65535)).max(16).optional(),
+    }))
+        .max(VPN_EGRESS_MAX_CUSTOM_RULES)
+        .optional(),
+};
+/** Adds `validateEgressSettings`' host/preset/merge rules to a tunnel schema. Problem strings never echo a rejected value. */
+function refineVpnEgressSettings(input, ctx) {
+    for (const message of validateEgressSettings({ egressPresets: input.egressPresets, egressAllow: input.egressAllow })) {
+        const field = message.startsWith("egressPresets") ? "egressPresets" : message.startsWith("egressAllow") ? "egressAllow" : null;
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message, path: field ? [field] : [] });
+    }
+}
+/**
+ * The shape-only form of the create/update bodies, WITHOUT the egress rules. The
+ * API route parses with these and then runs `resolveEgressChange`, which applies
+ * the same `validateEgressSettings` but answers with a structured 400 listing
+ * every problem (`errors`) rather than a generic schema error. Anything else
+ * should use `createVpnTunnelSchema` / `updateVpnTunnelSchema` below.
+ */
+export const createVpnTunnelBodySchema = z.object({
     name: vpnNameSchema,
     gatewayEndpoint: z.string().min(1).max(300),
     gatewayPublicKey: z.string().min(1).max(64),
@@ -582,8 +651,9 @@ export const createVpnTunnelSchema = z.object({
     /** Lab mode — allow a private (RFC1918/CGNAT) gateway endpoint. Setting it
      *  `true` is platform-admin only (enforced by the route, not here). */
     allowPrivateEndpoint: z.boolean().optional(),
+    ...vpnEgressSettingsFields,
 });
-export const updateVpnTunnelSchema = z.object({
+export const updateVpnTunnelBodySchema = z.object({
     name: vpnNameSchema.optional(),
     gatewayEndpoint: z.string().min(1).max(300).optional(),
     gatewayPublicKey: z.string().min(1).max(64).optional(),
@@ -598,6 +668,26 @@ export const updateVpnTunnelSchema = z.object({
      *  instead of queueing); `true` re-enables it, back to `pending` until
      *  the next handshake proves it works. */
     enabled: z.boolean().optional(),
+    ...vpnEgressSettingsFields,
+});
+/** The create body, with the egress rules (bare `*`, IP literals, unknown presets, merged port limit) enforced too. */
+export const createVpnTunnelSchema = createVpnTunnelBodySchema.superRefine(refineVpnEgressSettings);
+/** The update body, with the egress rules enforced too. */
+export const updateVpnTunnelSchema = updateVpnTunnelBodySchema.superRefine(refineVpnEgressSettings);
+/**
+ * The strict-egress allow-list (`VpnJobConfig.egress`; docs in vpn-egress.ts).
+ * Field-level shape and size bounds only; the host rules (no IP literals, no
+ * bare `*`, no trailing dot ...) live in `validateVpnEgressPolicy` so the
+ * server, the CLI and the agent apply the identical checks and report every
+ * problem at once. Tunnel settings (PR-D) will embed this.
+ */
+export const vpnEgressPolicySchema = z.object({
+    allow: z
+        .array(z.object({
+        host: z.string().min(1).max(253),
+        ports: z.array(z.number().int().min(1).max(65535)).max(16).optional(),
+    }))
+        .max(512),
 });
 /** `POST /agents/vpn/report` (apps/admin-api) — what the agent that holds
  *  an org's tunnel for a build tells the control plane about it. The