@better-openclaw/core 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-openclaw/core",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "private": false,
   "description": "Core logic for better-openclaw: schemas, service registry, resolver, composer, validators and more",
   "packageManager": "pnpm@9.15.4",

package/src/__snapshots__/composer.snapshot.test.ts.snap

@@ -164,6 +164,8 @@ exports[`compose snapshot tests > devops preset (n8n + postgresql + redis + moni
       N8N_HOST: n8n
       N8N_PORT: "5678"
       N8N_WEBHOOK_URL: http://n8n:5678/
+      GRAFANA_HOST: grafana
+      GRAFANA_PORT: "3000"
     volumes:
       - \${OPENCLAW_CONFIG_DIR:-./openclaw/config}:/home/node/.openclaw
       - \${OPENCLAW_WORKSPACE_DIR:-./openclaw/workspace}:/home/node/.openclaw/workspace
@@ -382,6 +384,8 @@ exports[`compose snapshot tests > full preset (many services) 1`] = `
       BROWSERLESS_HOST: browserless
       BROWSERLESS_PORT: "3000"
       BROWSERLESS_TOKEN: \${BROWSERLESS_TOKEN}
+      CADDY_HOST: caddy
+      CADDY_HTTP_PORT: "80"
       FFMPEG_SHARED_DIR: /home/node/.openclaw/workspace/media
       GOTIFY_HOST: gotify
       GOTIFY_PORT: "8080"
@@ -410,6 +414,8 @@ exports[`compose snapshot tests > full preset (many services) 1`] = `
       N8N_HOST: n8n
       N8N_PORT: "5678"
       N8N_WEBHOOK_URL: http://n8n:5678/
+      GRAFANA_HOST: grafana
+      GRAFANA_PORT: "3000"
     volumes:
       - \${OPENCLAW_CONFIG_DIR:-./openclaw/config}:/home/node/.openclaw
       - \${OPENCLAW_WORKSPACE_DIR:-./openclaw/workspace}:/home/node/.openclaw/workspace
@@ -433,7 +439,7 @@ exports[`compose snapshot tests > full preset (many services) 1`] = `
       browserless:
         condition: service_healthy
       caddy:
-        condition: service_started
+        condition: service_healthy
       meilisearch:
         condition: service_healthy
       minio:
@@ -474,6 +480,14 @@ exports[`compose snapshot tests > full preset (many services) 1`] = `
     volumes:
       - caddy-data:/data
       - caddy-config:/config
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - wget -q --spider http://localhost:80 || exit 1
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
     restart: unless-stopped
     networks:
       - openclaw-network

package/src/bare-metal-partition.ts

@@ -7,6 +7,7 @@ export function platformToNativePlatform(platform: Platform): NativePlatform {
 	if (platform.startsWith("linux/")) return "linux";
 	if (platform.startsWith("windows/")) return "windows";
 	if (platform.startsWith("macos/")) return "macos";
+	console.warn(`Unknown platform prefix in "${platform}", defaulting to linux`);
 	return "linux";
 }
 

package/src/composer.ts

@@ -100,6 +100,12 @@ function buildGatewayServices(
 		],
 	};
 
+	// Traefik labels for the gateway
+	const gwTraefikLabels = options.traefikLabels?.get("openclaw-gateway");
+	if (gwTraefikLabels) {
+		gateway.labels = gwTraefikLabels;
+	}
+
 	if (options.bareMetalNativeHost) {
 		gateway.extra_hosts = ["host.docker.internal:host-gateway"];
 	}
@@ -198,7 +204,22 @@ function buildCompanionService(
 
 	if (def.command) svc.command = def.command;
 	if (def.entrypoint) svc.entrypoint = def.entrypoint;
-	if (def.labels && Object.keys(def.labels).length > 0) svc.labels = def.labels;
+
+	// Labels: merge static definition labels with dynamic Traefik labels
+	const mergedLabels: Record<string, string> = {};
+	if (def.labels) Object.assign(mergedLabels, def.labels);
+	const traefikLabels = options.traefikLabels?.get(def.id);
+	if (traefikLabels) Object.assign(mergedLabels, traefikLabels);
+	if (Object.keys(mergedLabels).length > 0) svc.labels = mergedLabels;
+
+	// Traefik: bind-mount static config and Docker socket
+	if (def.id === "traefik" && options.traefikLabels) {
+		if (!svc.volumes) svc.volumes = [];
+		(svc.volumes as string[]).push(
+			"./traefik/traefik.yml:/etc/traefik/traefik.yml:ro",
+			"/var/run/docker.sock:/var/run/docker.sock:ro",
+		);
+	}
 
 	let deploy: Record<string, unknown> | undefined;
 	if (def.deploy) {

package/src/errors.ts

@@ -0,0 +1,23 @@
+/**
+ * Typed error classes for stack generation.
+ */
+
+/** Thrown when the resolved stack configuration is invalid (e.g. conflicts). */
+export class StackConfigError extends Error {
+	readonly code = "STACK_CONFIG_ERROR" as const;
+
+	constructor(message: string) {
+		super(message);
+		this.name = "StackConfigError";
+	}
+}
+
+/** Thrown when post-generation validation fails. */
+export class ValidationError extends Error {
+	readonly code = "VALIDATION_ERROR" as const;
+
+	constructor(message: string) {
+		super(message);
+		this.name = "ValidationError";
+	}
+}

package/src/generate.ts

@@ -7,6 +7,7 @@ import { composeMultiFile } from "./composer.js";
 import { generateBareMetalInstall } from "./generators/bare-metal-install.js";
 import { generateCaddyfile } from "./generators/caddy.js";
 import { generateEnvFiles } from "./generators/env.js";
+import { generateTraefikConfig } from "./generators/traefik.js";
 import { generateGrafanaConfig, generateGrafanaDashboard } from "./generators/grafana.js";
 import { generateN8nWorkflows } from "./generators/n8n-workflows.js";
 import { generateNativeInstallScripts } from "./generators/native-services.js";
@@ -15,6 +16,7 @@ import { generatePrometheusConfig } from "./generators/prometheus.js";
 import { generateReadme } from "./generators/readme.js";
 import { generateScripts } from "./generators/scripts.js";
 import { generateSkillFiles } from "./generators/skills.js";
+import { migrateConfig } from "./migrations.js";
 import { resolve } from "./resolver.js";
 import type {
 	GeneratedFiles,
@@ -23,6 +25,7 @@ import type {
 	Platform,
 	ResolverInput,
 } from "./types.js";
+import { StackConfigError, ValidationError } from "./errors.js";
 import { validate } from "./validator.js";
 
 /** Resolver/compose only support linux image platforms; normalize for bare-metal (windows/macos). */
@@ -35,7 +38,10 @@ function getComposePlatform(platform: Platform): "linux/amd64" | "linux/arm64" {
  * Main orchestration function: takes generation input, resolves dependencies,
  * generates all files, validates, and returns the complete file tree.
  */
-export function generate(input: GenerationInput): GenerationResult {
+export function generate(rawInput: GenerationInput): GenerationResult {
+	// Apply config migrations if needed
+	const input = migrateConfig(rawInput as Record<string, unknown>) as GenerationInput;
+
 	const composePlatform = getComposePlatform(input.platform);
 
 	// 1. Resolve dependencies
@@ -50,7 +56,7 @@ export function generate(input: GenerationInput): GenerationResult {
 	const resolved = resolve(resolverInput);
 
 	if (!resolved.isValid) {
-		throw new Error(
+		throw new StackConfigError(
 			`Invalid stack configuration: ${resolved.errors.map((e) => e.message).join("; ")}`,
 		);
 	}
@@ -72,6 +78,12 @@ export function generate(input: GenerationInput): GenerationResult {
 	}
 
 	// 2. Generate Docker Compose YAML (multi-file)
+	// Compute Traefik labels before composing (labels get injected into docker-compose services)
+	let traefikOutput: ReturnType<typeof generateTraefikConfig> | undefined;
+	if (input.proxy === "traefik" && input.domain) {
+		traefikOutput = generateTraefikConfig(resolvedForCompose, input.domain);
+	}
+
 	const composeOptions = {
 		projectName: input.projectName,
 		proxy: input.proxy,
@@ -81,6 +93,7 @@ export function generate(input: GenerationInput): GenerationResult {
 		deployment: input.deployment,
 		openclawVersion: input.openclawVersion,
 		bareMetalNativeHost: isBareMetal && nativeIds.size > 0,
+		traefikLabels: traefikOutput?.serviceLabels,
 	};
 	const composeResult = composeMultiFile(resolvedForCompose, composeOptions);
 
@@ -90,7 +103,7 @@ export function generate(input: GenerationInput): GenerationResult {
 		generateSecrets: input.generateSecrets,
 	});
 	if (!validation.valid) {
-		throw new Error(`Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`);
+		throw new ValidationError(`Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`);
 	}
 
 	// 4. Generate all files
@@ -158,6 +171,11 @@ export function generate(input: GenerationInput): GenerationResult {
 		files["caddy/Caddyfile"] = generateCaddyfile(resolved, input.domain);
 	}
 
+	// Traefik config (labels are already injected via composeOptions.traefikLabels)
+	if (traefikOutput) {
+		files["traefik/traefik.yml"] = traefikOutput.staticConfig;
+	}
+
 	// Prometheus config
 	const hasPrometheus = resolved.services.some((s) => s.definition.id === "prometheus");
 	if (hasPrometheus) {
@@ -223,7 +241,7 @@ export function generate(input: GenerationInput): GenerationResult {
 	};
 }
 
-function generateServicesDoc(resolved: import("./types.js").ResolverOutput): string {
+export function generateServicesDoc(resolved: import("./types.js").ResolverOutput): string {
 	const lines: string[] = [
 		"# Service Reference",
 		"",

package/src/generators/traefik.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { generateTraefikConfig } from "./traefik.js";
+import type { ResolverOutput } from "../types.js";
+import { resolve } from "../resolver.js";
+
+function resolveWith(services: string[]): ResolverOutput {
+	return resolve({ services, skillPacks: [], proxy: "traefik", gpu: false });
+}
+
+describe("generateTraefikConfig", () => {
+	const domain = "example.com";
+
+	it("generates static config with domain email and entrypoints", () => {
+		const resolved = resolveWith(["redis"]);
+		const { staticConfig } = generateTraefikConfig(resolved, domain);
+
+		expect(staticConfig).toContain("admin@example.com");
+		expect(staticConfig).toContain('address: ":80"');
+		expect(staticConfig).toContain('address: ":443"');
+		expect(staticConfig).toContain("exposedByDefault: false");
+		expect(staticConfig).toContain("openclaw-network");
+	});
+
+	it("generates labels for services with exposed ports", () => {
+		const resolved = resolveWith(["redis"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		const redisLabels = serviceLabels.get("redis");
+		expect(redisLabels).toBeDefined();
+		expect(redisLabels!["traefik.enable"]).toBe("true");
+		expect(redisLabels!["traefik.http.routers.redis.rule"]).toBe(
+			"Host(`redis.example.com`)",
+		);
+		expect(redisLabels!["traefik.http.routers.redis.entrypoints"]).toBe("websecure");
+		expect(redisLabels!["traefik.http.routers.redis.tls.certresolver"]).toBe("letsencrypt");
+		expect(redisLabels!["traefik.http.services.redis.loadbalancer.server.port"]).toBe("6379");
+	});
+
+	it("generates HTTP to HTTPS redirect labels", () => {
+		const resolved = resolveWith(["redis"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		const redisLabels = serviceLabels.get("redis")!;
+		expect(redisLabels["traefik.http.routers.redis-http.entrypoints"]).toBe("web");
+		expect(redisLabels["traefik.http.routers.redis-http.middlewares"]).toBe(
+			"redirect-to-https",
+		);
+	});
+
+	it("assigns root domain to gateway", () => {
+		const resolved = resolveWith(["redis"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		const gwLabels = serviceLabels.get("openclaw-gateway");
+		expect(gwLabels).toBeDefined();
+		expect(gwLabels!["traefik.http.routers.gateway.rule"]).toBe(
+			"Host(`example.com`)",
+		);
+		expect(gwLabels!["traefik.http.services.gateway.loadbalancer.server.port"]).toBe("18789");
+	});
+
+	it("adds global redirect middleware on traefik service", () => {
+		const resolved = resolveWith(["redis"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		const traefikLabels = serviceLabels.get("traefik");
+		expect(traefikLabels).toBeDefined();
+		expect(
+			traefikLabels!["traefik.http.middlewares.redirect-to-https.redirectscheme.scheme"],
+		).toBe("https");
+		expect(
+			traefikLabels!["traefik.http.middlewares.redirect-to-https.redirectscheme.permanent"],
+		).toBe("true");
+	});
+
+	it("skips proxy services and services without exposed ports", () => {
+		const resolved = resolveWith(["redis", "ffmpeg"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		// ffmpeg has no exposed ports
+		expect(serviceLabels.has("ffmpeg")).toBe(false);
+		// traefik itself is handled separately (not as a regular service)
+		expect(serviceLabels.get("traefik")!["traefik.http.routers.traefik.rule"]).toBeUndefined();
+	});
+
+	it("sanitizes service names with hyphens in router names", () => {
+		const resolved = resolveWith(["open-webui"]);
+		const { serviceLabels } = generateTraefikConfig(resolved, domain);
+
+		const labels = serviceLabels.get("open-webui");
+		expect(labels).toBeDefined();
+		// Router name has hyphens removed
+		expect(labels!["traefik.http.routers.openwebui.rule"]).toBe(
+			"Host(`open-webui.example.com`)",
+		);
+	});
+});

package/src/generators/traefik.ts

@@ -0,0 +1,104 @@
+import type { ResolverOutput } from "../types.js";
+
+export interface TraefikGeneratorOutput {
+	staticConfig: string;
+	serviceLabels: Map<string, Record<string, string>>;
+}
+
+/**
+ * Generates Traefik configuration: a static config YAML file and per-service
+ * Docker labels for automatic service discovery and reverse proxy routing.
+ *
+ * @param resolved - The resolved service configuration
+ * @param domain - The main domain for routing (e.g. "example.com")
+ * @returns Static config content and a map of serviceId → Docker labels
+ */
+export function generateTraefikConfig(
+	resolved: ResolverOutput,
+	domain: string,
+): TraefikGeneratorOutput {
+	const staticConfig = generateStaticConfig(domain);
+	const serviceLabels = new Map<string, Record<string, string>>();
+
+	// Per-service labels for exposed ports
+	for (const { definition } of resolved.services) {
+		if (definition.id === "traefik" || definition.id === "caddy") continue;
+
+		const exposedPorts = definition.ports.filter((p) => p.exposed);
+		if (exposedPorts.length === 0) continue;
+
+		const primaryPort = exposedPorts[0]!;
+		const routerName = definition.id.replace(/-/g, "");
+
+		const labels: Record<string, string> = {
+			"traefik.enable": "true",
+			// HTTPS router
+			[`traefik.http.routers.${routerName}.rule`]: `Host(\`${definition.id}.${domain}\`)`,
+			[`traefik.http.routers.${routerName}.entrypoints`]: "websecure",
+			[`traefik.http.routers.${routerName}.tls.certresolver`]: "letsencrypt",
+			[`traefik.http.services.${routerName}.loadbalancer.server.port`]: String(
+				primaryPort.container,
+			),
+			// HTTP → HTTPS redirect
+			[`traefik.http.routers.${routerName}-http.rule`]: `Host(\`${definition.id}.${domain}\`)`,
+			[`traefik.http.routers.${routerName}-http.entrypoints`]: "web",
+			[`traefik.http.routers.${routerName}-http.middlewares`]: "redirect-to-https",
+		};
+
+		serviceLabels.set(definition.id, labels);
+	}
+
+	// Gateway gets the root domain
+	serviceLabels.set("openclaw-gateway", {
+		"traefik.enable": "true",
+		"traefik.http.routers.gateway.rule": `Host(\`${domain}\`)`,
+		"traefik.http.routers.gateway.entrypoints": "websecure",
+		"traefik.http.routers.gateway.tls.certresolver": "letsencrypt",
+		"traefik.http.services.gateway.loadbalancer.server.port": "18789",
+		"traefik.http.routers.gateway-http.rule": `Host(\`${domain}\`)`,
+		"traefik.http.routers.gateway-http.entrypoints": "web",
+		"traefik.http.routers.gateway-http.middlewares": "redirect-to-https",
+	});
+
+	// Global redirect middleware on the Traefik service itself
+	serviceLabels.set("traefik", {
+		"traefik.enable": "true",
+		"traefik.http.middlewares.redirect-to-https.redirectscheme.scheme": "https",
+		"traefik.http.middlewares.redirect-to-https.redirectscheme.permanent": "true",
+	});
+
+	return { staticConfig, serviceLabels };
+}
+
+function generateStaticConfig(domain: string): string {
+	return `# Traefik Static Configuration — Auto-generated by OpenClaw
+# Domain: ${domain}
+
+api:
+  dashboard: true
+  insecure: true
+
+entryPoints:
+  web:
+    address: ":80"
+  websecure:
+    address: ":443"
+
+providers:
+  docker:
+    endpoint: "unix:///var/run/docker.sock"
+    exposedByDefault: false
+    network: openclaw-network
+
+certificatesResolvers:
+  letsencrypt:
+    acme:
+      email: admin@${domain}
+      storage: /letsencrypt/acme.json
+      httpChallenge:
+        entryPoint: web
+
+log:
+  level: INFO
+`;
+}

package/src/index.ts

@@ -8,7 +8,7 @@ export {
 } from "./bare-metal-partition.js";
 export type { ComposeResult } from "./composer.js";
 export { compose, composeMultiFile } from "./composer.js";
-export { generate } from "./generate.js";
+export { generate, generateServicesDoc } from "./generate.js";
 export { generateCaddyfile } from "./generators/caddy.js";
 export type { EnvVarGroup } from "./generators/env.js";
 export { generateEnvFiles, getStructuredEnvVars } from "./generators/env.js";
@@ -109,6 +109,12 @@ export type {
 export { SERVICE_CATEGORIES } from "./types.js";
 export { validate } from "./validator.js";
 
+// ─── Config Migrations ──────────────────────────────────────────────────────
+export { migrateConfig, needsMigration, CURRENT_CONFIG_VERSION } from "./migrations.js";
+
+// ─── Errors ─────────────────────────────────────────────────────────────────
+export { StackConfigError, ValidationError } from "./errors.js";
+
 // ─── Version Manager ────────────────────────────────────────────────────────
 export {
 	checkCompatibility,

package/src/migrations.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { migrateConfig, needsMigration, CURRENT_CONFIG_VERSION } from "./migrations.js";
+
+describe("config migrations", () => {
+	it("migrates v1 config to current version", () => {
+		const v1 = { projectName: "test", services: ["redis"], skillPacks: [] };
+		const result = migrateConfig(v1);
+		expect(result.configVersion).toBe(CURRENT_CONFIG_VERSION);
+		expect(result.deploymentType).toBe("docker");
+	});
+
+	it("preserves existing deploymentType during migration", () => {
+		const v1 = { configVersion: 1, deploymentType: "bare-metal" };
+		const result = migrateConfig(v1);
+		expect(result.deploymentType).toBe("bare-metal");
+	});
+
+	it("passes through current version unchanged", () => {
+		const current = { configVersion: CURRENT_CONFIG_VERSION, projectName: "test" };
+		const result = migrateConfig(current);
+		expect(result).toEqual(current);
+	});
+
+	it("needsMigration returns true for old configs", () => {
+		expect(needsMigration({ configVersion: 1 })).toBe(true);
+		expect(needsMigration({})).toBe(true); // no version = v1
+	});
+
+	it("needsMigration returns false for current configs", () => {
+		expect(needsMigration({ configVersion: CURRENT_CONFIG_VERSION })).toBe(false);
+	});
+
+	it("throws for unknown version with no migration path", () => {
+		expect(() => migrateConfig({ configVersion: 99 })).toThrow("No migration path");
+	});
+});

package/src/migrations.ts

@@ -0,0 +1,49 @@
+import type { GenerationInput } from "./types.js";
+
+export const CURRENT_CONFIG_VERSION = 2;
+
+type MigrationFn = (input: Record<string, unknown>) => Record<string, unknown>;
+
+const migrations: Record<number, MigrationFn> = {
+	// v1 → v2: ensure deploymentType field exists (defaulting to "docker")
+	1: (input) => ({
+		...input,
+		configVersion: 2,
+		deploymentType: (input.deploymentType as string) ?? "docker",
+	}),
+};
+
+/**
+ * Applies sequential migrations to bring a config from its current version
+ * to CURRENT_CONFIG_VERSION. Returns the config unchanged if already current.
+ */
+export function migrateConfig(input: Record<string, unknown>): Record<string, unknown> {
+	let version = (input.configVersion as number) ?? 1;
+
+	if (version > CURRENT_CONFIG_VERSION) {
+		throw new Error(
+			`No migration path from config version ${version}`,
+		);
+	}
+
+	let current = { ...input };
+
+	while (version < CURRENT_CONFIG_VERSION) {
+		const migrationFn = migrations[version];
+		if (!migrationFn) {
+			throw new Error(`No migration path from config version ${version}`);
+		}
+		current = migrationFn(current);
+		version++;
+	}
+
+	return current;
+}
+
+/**
+ * Returns true if the config needs migration to the current version.
+ */
+export function needsMigration(input: Record<string, unknown>): boolean {
+	const version = (input.configVersion as number) ?? 1;
+	return version < CURRENT_CONFIG_VERSION;
+}

package/src/resolver.ts

@@ -10,6 +10,18 @@ import type {
 	Warning,
 } from "./types.js";
 
+export interface MemoryThresholds {
+	info: number;
+	warning: number;
+	critical: number;
+}
+
+const DEFAULT_MEMORY_THRESHOLDS: MemoryThresholds = {
+	info: 2048,
+	warning: 4096,
+	critical: 8192,
+};
+
 /**
  * Resolves user selections into a complete, valid service list.
  *
@@ -128,6 +140,27 @@ export function resolve(input: ResolverInput): ResolverOutput {
 		}
 	}
 
+	if (iteration >= maxIterations) {
+		warnings.push({
+			type: "resolution",
+			message: `Dependency resolution reached maximum iterations (${maxIterations}). Some transitive dependencies may not be fully resolved.`,
+		});
+	}
+
+	// Check recommended services
+	for (const id of serviceIds) {
+		const def = getServiceById(id);
+		if (!def) continue;
+		for (const recId of def.recommends) {
+			if (!serviceIds.has(recId) && getServiceById(recId)) {
+				warnings.push({
+					type: "recommendation",
+					message: `${def.name} recommends "${recId}" for enhanced functionality`,
+				});
+			}
+		}
+	}
+
 	// 3. Detect conflicts
 	const resolvedDefs: ServiceDefinition[] = [];
 	for (const id of serviceIds) {
@@ -178,17 +211,18 @@ export function resolve(input: ResolverInput): ResolverOutput {
 	}
 
 	// Memory warnings
-	if (estimatedMemoryMB > 8192) {
+	const thresholds = input.memoryThresholds ?? DEFAULT_MEMORY_THRESHOLDS;
+	if (estimatedMemoryMB > thresholds.critical) {
 		warnings.push({
 			type: "memory",
 			message: `Estimated ${(estimatedMemoryMB / 1024).toFixed(1)}GB RAM required. Ensure your server has sufficient resources.`,
 		});
-	} else if (estimatedMemoryMB > 4096) {
+	} else if (estimatedMemoryMB > thresholds.warning) {
 		warnings.push({
 			type: "memory",
 			message: `Estimated ${(estimatedMemoryMB / 1024).toFixed(1)}GB RAM required. A server with at least 8GB RAM is recommended.`,
 		});
-	} else if (estimatedMemoryMB > 2048) {
+	} else if (estimatedMemoryMB > thresholds.info) {
 		warnings.push({
 			type: "memory",
 			message: `Estimated ${(estimatedMemoryMB / 1024).toFixed(1)}GB RAM required.`,

package/src/schema.ts

@@ -201,6 +201,7 @@ export const PresetSchema = z.object({
 // ─── Generation Input ───────────────────────────────────────────────────────
 
 export const GenerationInputSchema = z.object({
+	configVersion: z.number().int().min(1).optional(),
 	projectName: z
 		.string()
 		.min(1)

package/src/services/definitions/caddy.ts

@@ -37,12 +37,34 @@ export const caddyDefinition: ServiceDefinition = {
 		},
 	],
 	environment: [],
+	healthcheck: {
+		test: "wget -q --spider http://localhost:80 || exit 1",
+		interval: "30s",
+		timeout: "10s",
+		retries: 3,
+		startPeriod: "5s",
+	},
 	dependsOn: [],
 	restartPolicy: "unless-stopped",
 	networks: ["openclaw-network"],
 
 	skills: [],
-	openclawEnvVars: [],
+	openclawEnvVars: [
+		{
+			key: "CADDY_HOST",
+			defaultValue: "caddy",
+			secret: false,
+			description: "Caddy reverse proxy hostname",
+			required: false,
+		},
+		{
+			key: "CADDY_HTTP_PORT",
+			defaultValue: "80",
+			secret: false,
+			description: "Caddy HTTP port",
+			required: false,
+		},
+	],
 
 	docsUrl: "https://caddyserver.com/docs/",
 	tags: ["reverse-proxy", "auto-https", "ssl"],