Merge pull request #250 from techulus/fix/serverless-http-visibility

Constrain serverless settings to HTTP services

Author: arjunkomath

docs/api/public-api.mdx

@@ -143,6 +143,8 @@ Configuration and revision responses never include secret names, values, or ciph
 
 `PUT /configuration` is atomic and replaces the complete managed configuration. Send the `currentVersion` returned by the plan as one quoted strong ETag (for example, `If-Match: "sha256:…"`). Missing, unquoted, multiple, weak, or otherwise invalid headers are rejected; a service change after planning returns `409 CONFIGURATION_PLAN_STALE`. A successful response returns the authoritative target and the structured change set that was applied. The request must contain exactly `name`, `source`, `hostname`, `ports`, `placement`, `healthCheck`, `startCommand`, and `resources`. Omitted or unknown fields are rejected. `hostname` must be concrete and non-null. Use `null` to clear nullable fields, including `resources`.
 
+Replacing the final public HTTP port with a domain automatically disables serverless in the mutable service configuration. The plan reports this side effect as a `serverless.enabled` change before apply. You do not send serverless settings in the replacement request.
+
 ```json
 {
   "name": "web",
@@ -215,7 +217,7 @@ Use manual placement to choose exact servers:
 }
 ```
 
-Manual placement requires online servers with WireGuard configured. Serverless services require proxy servers, including when automatic placement is used. Automatic placement is not available for stateful or volume-backed services. Submit replica changes through `placement`; the API rejects a top-level `replicas` field.
+Manual placement requires online servers with WireGuard configured. Serverless services require proxy servers, including when automatic placement is used. A replacement that removes the final public HTTP domain can move the service to worker placement because the same update disables serverless. Automatic placement is not available for stateful or volume-backed services. Submit replica changes through `placement`; the API rejects a top-level `replicas` field.
 
 The API only manages stateless services with HTTP ports. Existing volumes, stateful mode, TCP or UDP ports, TLS passthrough, or invalid resource limits return a conflict with an actionable code.
 

docs/services/scaling.mdx

@@ -30,6 +30,10 @@ Serverless settings are configured per service:
 | Sleep after | `300s` | Idle period before running containers are stopped |
 | Wake timeout | `300s` | Maximum time the wake gateway waits for ready upstreams |
 
+The serverless settings appear only when the service has a public HTTP port with
+a domain. Removing the final qualifying endpoint disables serverless in the
+pending service configuration.
+
 A cold wake starts the sleeping local proxy replicas for that host. Held
 requests resume when one upstream is ready.
 

web/actions/projects.ts

@@ -1225,6 +1225,17 @@ export async function updateServiceConfig(
 					})),
 				);
 				if (issue) throw new Error(issue.message);
+				if (
+					!finalPorts.some(
+						(port) =>
+							port.isPublic && port.protocol === "http" && port.domain !== null,
+					)
+				) {
+					await tx
+						.update(services)
+						.set({ serverlessEnabled: false })
+						.where(eq(services.id, serviceId));
+				}
 
 				for (const port of additions) {
 					if (!port.domain) continue;

web/components/service/details/serverless-section.tsx

@@ -19,6 +19,11 @@ export const ServerlessSection = memo(function ServerlessSection(
 	props: ServerlessSectionProps,
 ) {
 	const { service } = props;
+	const hasPublicHttpEndpoint = service.ports.some(
+		(port) => port.isPublic && port.protocol === "http" && !!port.domain,
+	);
+	if (!hasPublicHttpEndpoint) return null;
+
 	// Persisted changes are authoritative and intentionally discard any stale local draft.
 	const settingsKey = `${service.id}:${service.serverlessEnabled}:${service.serverlessSleepAfterSeconds}:${service.serverlessWakeTimeoutSeconds}`;
 
@@ -47,21 +52,12 @@ function ServerlessSectionEditor({
 	const [wakeTimeoutSeconds, setWakeTimeoutSeconds] = useState(
 		String(service.serverlessWakeTimeoutSeconds ?? 300),
 	);
-	const hasPublicHttpEndpoint = useMemo(
-		() =>
-			service.ports.some(
-				(port) => port.isPublic && port.protocol === "http" && !!port.domain,
-			),
-		[service.ports],
-	);
 	const hasWorkerReplica = service.configuredReplicas.some(
 		(replica) => replica.count > 0 && !replica.serverIsProxy,
 	);
-	const unavailableReason = !hasPublicHttpEndpoint
-		? "Add a public HTTP port with a domain to enable serverless"
-		: hasWorkerReplica
-			? "Serverless services can only be deployed to proxy nodes"
-			: null;
+	const unavailableReason = hasWorkerReplica
+		? "Serverless services can only be deployed to proxy nodes"
+		: null;
 	const optionsDisabled = !!unavailableReason || isSaving;
 
 	const parsed = useMemo(

web/lib/public-api.ts

@@ -694,6 +694,7 @@ function canonicalReplacementState(
 		healthCheck: healthCheckFromService(service),
 		startCommand: service.startCommand?.trim() || null,
 		resources,
+		serverless: { enabled: service.serverlessEnabled },
 	};
 }
 
@@ -773,7 +774,15 @@ export function planCanonicalConfiguration(
 		...current,
 		source: canonicalPlanSource(current.source),
 	};
-	const desired = canonicalDesired(desiredInput);
+	const desiredConfiguration = canonicalDesired(desiredInput);
+	const desired = {
+		...desiredConfiguration,
+		serverless: {
+			enabled:
+				canonicalCurrent.serverless.enabled &&
+				desiredConfiguration.ports.some((port) => port.public && port.domain),
+		},
+	};
 	const changes = configurationChanges(canonicalCurrent, desired);
 	return {
 		action: changes.length ? ("updated" as const) : ("noop" as const),
@@ -869,6 +878,9 @@ async function replaceConfigurationInternal(
 			);
 		}
 		const plan = planCanonicalConfiguration(currentState, input);
+		const effectiveServerlessEnabled =
+			persisted.serverlessEnabled &&
+			input.ports.some((port) => port.public && port.domain);
 		if (expectedVersion !== null && plan.currentVersion !== expectedVersion) {
 			domainError(
 				"Service configuration changed after the plan was created",
@@ -946,7 +958,7 @@ async function replaceConfigurationInternal(
 					400,
 				);
 			if (
-				persisted.serverlessEnabled &&
+				effectiveServerlessEnabled &&
 				selected.some((server) => !server.isProxy)
 			)
 				domainError(
@@ -967,16 +979,6 @@ async function replaceConfigurationInternal(
 		if (duplicateHostname) {
 			domainError("Hostname is already in use", "HOSTNAME_CONFLICT");
 		}
-		if (
-			persisted.serverlessEnabled &&
-			!input.ports.some((port) => port.public && port.domain)
-		) {
-			domainError(
-				"Serverless services require a public HTTP port with a domain",
-				"SERVERLESS_PORT_REQUIRED",
-				400,
-			);
-		}
 		const portIssue = findServicePortValidationIssue(
 			input.ports.map((port) => ({
 				containerPort: port.containerPort,
@@ -1013,6 +1015,9 @@ async function replaceConfigurationInternal(
 
 		const changes: string[] = [];
 		const set: Partial<NestedService> = {};
+		if (persisted.serverlessEnabled !== effectiveServerlessEnabled) {
+			set.serverlessEnabled = effectiveServerlessEnabled;
+		}
 		const changed = (label: string, from: unknown, to: unknown) => {
 			if (JSON.stringify(from) === JSON.stringify(to)) return false;
 			changes.push(label);

web/tests/public-api-plan.test.ts

@@ -47,13 +47,20 @@ describe("configuration plan protocol", () => {
 			healthCheck: null,
 			startCommand: null,
 			resources: null,
+			serverless: { enabled: false },
 		};
 		const result = planCanonicalConfiguration(current, {
-			...current,
+			name: current.name,
 			source: {
 				...current.source,
 				repository: "https://github.com/techulus/cloud",
 			},
+			hostname: current.hostname,
+			ports: current.ports,
+			placement: current.placement,
+			healthCheck: current.healthCheck,
+			startCommand: current.startCommand,
+			resources: current.resources,
 		});
 
 		expect(result.action).toBe("noop");
@@ -113,6 +120,7 @@ describe("configuration plan protocol", () => {
 			},
 			startCommand: "npm start",
 			resources: { cpuCores: 2, memoryMb: 512 },
+			serverless: { enabled: false },
 		};
 		const result = planCanonicalConfiguration(current, {
 			name: "web",
@@ -174,6 +182,7 @@ describe("configuration plan protocol", () => {
 			healthCheck: null,
 			startCommand: null,
 			resources: null,
+			serverless: { enabled: false },
 		};
 		const desired = {
 			name: "web",
@@ -208,4 +217,80 @@ describe("configuration plan protocol", () => {
 		expect(first.changes).toEqual([]);
 		expect(second.desiredVersion).toBe(first.desiredVersion);
 	});
+
+	it("plans disabling serverless when the final public HTTP domain is removed", () => {
+		const current = {
+			name: "web",
+			source: { type: "image" as const, image: "nginx" },
+			hostname: "web",
+			ports: [{ containerPort: 8080, public: true, domain: "web.example.com" }],
+			placement: { mode: "automatic" as const, replicas: 1 },
+			healthCheck: null,
+			startCommand: null,
+			resources: null,
+			serverless: { enabled: true },
+		};
+		const desired = {
+			name: "web",
+			source: { type: "image" as const, image: "nginx" },
+			hostname: "web",
+			ports: [{ containerPort: 8080, public: false }],
+			placement: { mode: "automatic" as const, replicas: 1 },
+			healthCheck: null,
+			startCommand: null,
+			resources: null,
+		};
+
+		const result = planCanonicalConfiguration(current, desired);
+
+		expect(result.changes).toContainEqual({
+			field: "serverless.enabled",
+			from: true,
+			to: false,
+		});
+		expect(
+			planCanonicalConfiguration(
+				{ ...current, serverless: { enabled: false } },
+				desired,
+			).changes,
+		).not.toContainEqual(
+			expect.objectContaining({ field: "serverless.enabled" }),
+		);
+	});
+
+	it("preserves serverless and fingerprints its state when a public domain remains", () => {
+		const current = {
+			name: "web",
+			source: { type: "image" as const, image: "nginx" },
+			hostname: "web",
+			ports: [{ containerPort: 8080, public: true, domain: "web.example.com" }],
+			placement: { mode: "automatic" as const, replicas: 1 },
+			healthCheck: null,
+			startCommand: null,
+			resources: null,
+			serverless: { enabled: true },
+		};
+		const desired = {
+			name: current.name,
+			source: current.source,
+			hostname: current.hostname,
+			ports: current.ports,
+			placement: current.placement,
+			healthCheck: current.healthCheck,
+			startCommand: current.startCommand,
+			resources: current.resources,
+		};
+
+		const enabled = planCanonicalConfiguration(current, desired);
+		const disabled = planCanonicalConfiguration(
+			{ ...current, serverless: { enabled: false } },
+			desired,
+		);
+
+		expect(enabled.action).toBe("noop");
+		expect(enabled.changes).toEqual([]);
+		expect(disabled.action).toBe("noop");
+		expect(disabled.currentVersion).not.toBe(enabled.currentVersion);
+		expect(disabled.desiredVersion).not.toBe(enabled.desiredVersion);
+	});
 });