@better-openclaw/core 1.0.8 → 1.0.9

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"],

package/src/services/definitions/cal-com.ts

@@ -0,0 +1,91 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const calComDefinition: ServiceDefinition = {
+	id: "cal-com",
+	name: "Cal.com",
+	description:
+		"Open-source scheduling platform for appointments, meetings, and booking management with calendar integrations and customizable workflows.",
+	category: "automation",
+	icon: "📅",
+
+	image: "calcom/cal.com",
+	imageTag: "latest",
+	ports: [
+		{
+			host: 3005,
+			container: 3000,
+			description: "Cal.com web UI",
+			exposed: true,
+		},
+	],
+	volumes: [],
+	environment: [
+		{
+			key: "DATABASE_URL",
+			defaultValue: "postgresql://calcom:${CALCOM_DB_PASSWORD}@postgresql:5432/calcom",
+			secret: true,
+			description: "PostgreSQL connection URL for Cal.com",
+			required: true,
+		},
+		{
+			key: "NEXTAUTH_SECRET",
+			defaultValue: "",
+			secret: true,
+			description: "NextAuth.js session encryption secret",
+			required: true,
+		},
+		{
+			key: "CALENDSO_ENCRYPTION_KEY",
+			defaultValue: "",
+			secret: true,
+			description: "Encryption key for calendar data at rest",
+			required: true,
+		},
+		{
+			key: "NEXT_PUBLIC_WEBAPP_URL",
+			defaultValue: "http://localhost:3005",
+			secret: false,
+			description: "Public URL of the Cal.com instance",
+			required: true,
+		},
+	],
+	healthcheck: {
+		test: "wget -q --spider http://localhost:3000 || exit 1",
+		interval: "30s",
+		timeout: "10s",
+		retries: 3,
+		startPeriod: "60s",
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	skills: [],
+	openclawEnvVars: [
+		{
+			key: "CALCOM_HOST",
+			defaultValue: "cal-com",
+			secret: false,
+			description: "Cal.com hostname for OpenClaw",
+			required: true,
+		},
+		{
+			key: "CALCOM_PORT",
+			defaultValue: "3000",
+			secret: false,
+			description: "Cal.com port for OpenClaw",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://cal.com/docs",
+	tags: ["calendar", "scheduling", "booking", "appointments"],
+	maturity: "beta",
+
+	requires: ["postgresql"],
+	recommends: ["redis"],
+	conflictsWith: [],
+
+	minMemoryMB: 512,
+	gpuRequired: false,
+};

package/src/services/definitions/grafana.ts

@@ -53,7 +53,22 @@ export const grafanaDefinition: ServiceDefinition = {
 	networks: ["openclaw-network"],
 
 	skills: [],
-	openclawEnvVars: [],
+	openclawEnvVars: [
+		{
+			key: "GRAFANA_HOST",
+			defaultValue: "grafana",
+			secret: false,
+			description: "Grafana hostname",
+			required: false,
+		},
+		{
+			key: "GRAFANA_PORT",
+			defaultValue: "3000",
+			secret: false,
+			description: "Grafana internal port",
+			required: false,
+		},
+	],
 
 	docsUrl: "https://grafana.com/docs/grafana/latest/",
 	tags: ["dashboards", "visualization", "metrics", "monitoring"],

package/src/services/definitions/index.ts

@@ -3,6 +3,7 @@ export { appflowyDefinition } from "./appflowy.js";
 export { beszelDefinition } from "./beszel.js";
 export { browserlessDefinition } from "./browserless.js";
 export { caddyDefinition } from "./caddy.js";
+export { calComDefinition } from "./cal-com.js";
 export { chromadbDefinition } from "./chromadb.js";
 export { claudeCodeDefinition } from "./claude-code.js";
 export { codeServerDefinition } from "./code-server.js";
@@ -39,6 +40,7 @@ export { minioDefinition } from "./minio.js";
 export { mixpostDefinition } from "./mixpost.js";
 export { motionCanvasDefinition } from "./motion-canvas.js";
 export { n8nDefinition } from "./n8n.js";
+export { neo4jDefinition } from "./neo4j.js";
 export { nocodbDefinition } from "./nocodb.js";
 export { ntfyDefinition } from "./ntfy.js";
 export { ollamaDefinition } from "./ollama.js";
@@ -70,6 +72,7 @@ export { valkeyDefinition } from "./valkey.js";
 export { watchtowerDefinition } from "./watchtower.js";
 export { weaviateDefinition } from "./weaviate.js";
 export { whisperDefinition } from "./whisper.js";
+export { xyopsDefinition } from "./xyops.js";
 
 import type { ServiceDefinition } from "../../types.js";
 import { anythingLlmDefinition } from "./anything-llm.js";
@@ -77,6 +80,7 @@ import { appflowyDefinition } from "./appflowy.js";
 import { beszelDefinition } from "./beszel.js";
 import { browserlessDefinition } from "./browserless.js";
 import { caddyDefinition } from "./caddy.js";
+import { calComDefinition } from "./cal-com.js";
 import { chromadbDefinition } from "./chromadb.js";
 import { claudeCodeDefinition } from "./claude-code.js";
 import { codeServerDefinition } from "./code-server.js";
@@ -113,6 +117,7 @@ import { minioDefinition } from "./minio.js";
 import { mixpostDefinition } from "./mixpost.js";
 import { motionCanvasDefinition } from "./motion-canvas.js";
 import { n8nDefinition } from "./n8n.js";
+import { neo4jDefinition } from "./neo4j.js";
 import { nocodbDefinition } from "./nocodb.js";
 import { ntfyDefinition } from "./ntfy.js";
 import { ollamaDefinition } from "./ollama.js";
@@ -144,6 +149,7 @@ import { valkeyDefinition } from "./valkey.js";
 import { watchtowerDefinition } from "./watchtower.js";
 import { weaviateDefinition } from "./weaviate.js";
 import { whisperDefinition } from "./whisper.js";
+import { xyopsDefinition } from "./xyops.js";
 
 export const allServiceDefinitions: ServiceDefinition[] = [
 	redisDefinition,
@@ -218,4 +224,7 @@ export const allServiceDefinitions: ServiceDefinition[] = [
 	lasuiteMeetAgentsDefinition,
 	desktopEnvironmentDefinition,
 	streamGatewayDefinition,
+	neo4jDefinition,
+	calComDefinition,
+	xyopsDefinition,
 ];

package/src/services/definitions/neo4j.ts

@@ -0,0 +1,96 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const neo4jDefinition: ServiceDefinition = {
+	id: "neo4j",
+	name: "Neo4j",
+	description:
+		"Graph database platform for connected data, enabling knowledge graphs, fraud detection, and relationship-driven queries with the Cypher query language.",
+	category: "database",
+	icon: "🔵",
+
+	image: "neo4j",
+	imageTag: "5-community",
+	ports: [
+		{
+			host: 7474,
+			container: 7474,
+			description: "Neo4j Browser (HTTP)",
+			exposed: true,
+		},
+		{
+			host: 7687,
+			container: 7687,
+			description: "Bolt protocol",
+			exposed: true,
+		},
+	],
+	volumes: [
+		{
+			name: "neo4j-data",
+			containerPath: "/data",
+			description: "Persistent Neo4j data",
+		},
+	],
+	environment: [
+		{
+			key: "NEO4J_AUTH",
+			defaultValue: "neo4j/${NEO4J_PASSWORD}",
+			secret: true,
+			description: "Neo4j authentication credentials (user/password)",
+			required: true,
+		},
+	],
+	healthcheck: {
+		test: "wget -q --spider http://localhost:7474 || exit 1",
+		interval: "30s",
+		timeout: "10s",
+		retries: 3,
+		startPeriod: "30s",
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	skills: [],
+	openclawEnvVars: [
+		{
+			key: "NEO4J_HOST",
+			defaultValue: "neo4j",
+			secret: false,
+			description: "Neo4j hostname for OpenClaw",
+			required: true,
+		},
+		{
+			key: "NEO4J_BOLT_PORT",
+			defaultValue: "7687",
+			secret: false,
+			description: "Neo4j Bolt protocol port for OpenClaw",
+			required: true,
+		},
+		{
+			key: "NEO4J_HTTP_PORT",
+			defaultValue: "7474",
+			secret: false,
+			description: "Neo4j HTTP port for OpenClaw",
+			required: true,
+		},
+		{
+			key: "NEO4J_PASSWORD",
+			defaultValue: "",
+			secret: true,
+			description: "Neo4j password for OpenClaw",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://neo4j.com/docs/",
+	tags: ["graph", "database", "knowledge-graph", "cypher"],
+	maturity: "stable",
+
+	requires: [],
+	recommends: [],
+	conflictsWith: [],
+
+	minMemoryMB: 512,
+	gpuRequired: false,
+};

package/src/services/definitions/traefik.ts

@@ -38,8 +38,6 @@ export const traefikDefinition: ServiceDefinition = {
 		},
 	],
 	environment: [],
-	command:
-		"--api.dashboard=true --providers.docker=true --entrypoints.web.address=:80 --entrypoints.websecure.address=:443",
 	dependsOn: [],
 	restartPolicy: "unless-stopped",
 	networks: ["openclaw-network"],

package/src/services/definitions/xyops.ts

@@ -0,0 +1,94 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const xyopsDefinition: ServiceDefinition = {
+	id: "xyops",
+	name: "xyOps",
+	description:
+		"Job scheduling, workflow automation, server monitoring, alerting, and incident response platform with a visual workflow editor and fleet management.",
+	category: "automation",
+	icon: "⚙️",
+
+	image: "ghcr.io/pixlcore/xyops",
+	imageTag: "latest",
+	ports: [
+		{
+			host: 5522,
+			container: 5522,
+			description: "xyOps web interface",
+			exposed: true,
+		},
+		{
+			host: 5523,
+			container: 5523,
+			description: "xyOps secondary service",
+			exposed: false,
+		},
+	],
+	volumes: [
+		{
+			name: "xyops-data",
+			containerPath: "/opt/xyops/data",
+			description: "Persistent xyOps data and configuration",
+		},
+		{
+			name: "/var/run/docker.sock",
+			containerPath: "/var/run/docker.sock",
+			description: "Docker socket for container management",
+		},
+	],
+	environment: [
+		{
+			key: "TZ",
+			defaultValue: "UTC",
+			secret: false,
+			description: "Timezone for xyOps",
+			required: false,
+		},
+		{
+			key: "XYOPS_xysat_local",
+			defaultValue: "1",
+			secret: false,
+			description: "Enable local satellite mode for monitoring the host",
+			required: false,
+		},
+	],
+	healthcheck: {
+		test: "wget -q --spider http://localhost:5522 || exit 1",
+		interval: "30s",
+		timeout: "10s",
+		retries: 3,
+		startPeriod: "30s",
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	skills: [],
+	openclawEnvVars: [
+		{
+			key: "XYOPS_HOST",
+			defaultValue: "xyops",
+			secret: false,
+			description: "xyOps hostname for OpenClaw",
+			required: true,
+		},
+		{
+			key: "XYOPS_PORT",
+			defaultValue: "5522",
+			secret: false,
+			description: "xyOps port for OpenClaw",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://github.com/pixlcore/xyops",
+	tags: ["scheduling", "automation", "monitoring", "alerting", "incident-response", "workflow"],
+	maturity: "stable",
+
+	requires: [],
+	recommends: [],
+	conflictsWith: [],
+
+	minMemoryMB: 256,
+	gpuRequired: false,
+};

package/src/types.ts

@@ -58,7 +58,10 @@ export type SkillPack = z.infer<typeof SkillPackSchema>;
 export type Preset = z.infer<typeof PresetSchema>;
 
 export type GenerationInput = z.infer<typeof GenerationInputSchema>;
-export type ComposeOptions = z.infer<typeof ComposeOptionsSchema>;
+export type ComposeOptions = z.infer<typeof ComposeOptionsSchema> & {
+	/** Dynamic Traefik labels per service, computed by the Traefik generator. */
+	traefikLabels?: Map<string, Record<string, string>>;
+};
 export type ResolvedService = z.infer<typeof ResolvedServiceSchema>;
 export type AddedDependency = z.infer<typeof AddedDependencySchema>;
 export type Warning = z.infer<typeof WarningSchema>;
@@ -78,6 +81,7 @@ export interface ResolverInput {
 	gpu?: boolean;
 	platform?: Platform;
 	monitoring?: boolean;
+	memoryThresholds?: { info: number; warning: number; critical: number };
 }
 
 export interface GeneratedFiles {

package/src/validator.ts

@@ -93,6 +93,22 @@ function checkEnvCompleteness(
 					message: `Secret "${envVar.key}" for "${svc.definition.name}" needs to be configured manually`,
 				});
 			}
+			if (envVar.validation && envVar.defaultValue) {
+				try {
+					const regex = new RegExp(envVar.validation);
+					if (!regex.test(envVar.defaultValue)) {
+						warnings.push({
+							type: "env_validation",
+							message: `Environment variable "${envVar.key}" for "${svc.definition.name}" default value does not match validation pattern: ${envVar.validation}`,
+						});
+					}
+				} catch {
+					warnings.push({
+						type: "env_validation",
+						message: `Environment variable "${envVar.key}" for "${svc.definition.name}" has invalid validation regex: ${envVar.validation}`,
+					});
+				}
+			}
 		}
 	}
 }

package/src/version-manager.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { resolve } from "./resolver.js";
+import { getAllServices, getServiceById } from "./services/registry.js";
+import { checkCompatibility, getImageReference, getImageTag, pinImageTags } from "./version-manager.js";
+
+describe("getImageTag", () => {
+	it("returns the tag for a known service", () => {
+		const tag = getImageTag("redis");
+		expect(tag).toBeDefined();
+		expect(typeof tag).toBe("string");
+	});
+
+	it("returns undefined for an unknown service", () => {
+		expect(getImageTag("nonexistent-service-xyz")).toBeUndefined();
+	});
+});
+
+describe("getImageReference", () => {
+	it("returns image:tag for a known service", () => {
+		const ref = getImageReference("redis");
+		expect(ref).toBeDefined();
+		expect(ref).toContain(":");
+		expect(ref).toMatch(/^.+:.+$/);
+	});
+
+	it("returns undefined for an unknown service", () => {
+		expect(getImageReference("nonexistent-service-xyz")).toBeUndefined();
+	});
+});
+
+describe("pinImageTags", () => {
+	it("pins image tags from the registry for all services", () => {
+		const resolved = resolve({
+			services: ["redis", "postgresql"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+		});
+
+		const pinned = pinImageTags(resolved);
+
+		expect(pinned.services).toHaveLength(resolved.services.length);
+
+		for (const svc of pinned.services) {
+			expect(svc.definition.imageTag).toBeDefined();
+			expect(typeof svc.definition.imageTag).toBe("string");
+			expect(svc.definition.imageTag.length).toBeGreaterThan(0);
+		}
+	});
+
+	it("does not mutate the original resolved output", () => {
+		const resolved = resolve({
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+		});
+
+		const originalTag = resolved.services[0]?.definition.imageTag;
+		pinImageTags(resolved);
+
+		expect(resolved.services[0]?.definition.imageTag).toBe(originalTag);
+	});
+
+	it("preserves non-tag properties", () => {
+		const resolved = resolve({
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+		});
+
+		const pinned = pinImageTags(resolved);
+		expect(pinned.services[0]?.definition.id).toBe("redis");
+		expect(pinned.services[0]?.definition.name).toBe("Redis");
+		expect(pinned.estimatedMemoryMB).toBe(resolved.estimatedMemoryMB);
+	});
+});
+
+describe("checkCompatibility", () => {
+	it("warns when Redis and Valkey are both selected", () => {
+		const all = getAllServices();
+		const redis = all.find((s) => s.id === "redis");
+		const valkey = all.find((s) => s.id === "valkey");
+
+		if (redis && valkey) {
+			const warnings = checkCompatibility([redis, valkey]);
+			expect(warnings.some((w) => w.message.includes("Redis") && w.message.includes("Valkey"))).toBe(true);
+		}
+	});
+
+	it("warns when Caddy and Traefik are both selected", () => {
+		const all = getAllServices();
+		const caddy = all.find((s) => s.id === "caddy");
+		const traefik = all.find((s) => s.id === "traefik");
+
+		if (caddy && traefik) {
+			const warnings = checkCompatibility([caddy, traefik]);
+			expect(warnings.some((w) => w.message.includes("Caddy") && w.message.includes("Traefik"))).toBe(true);
+		}
+	});
+
+	it("warns about multiple vector databases", () => {
+		const all = getAllServices();
+		const qdrant = all.find((s) => s.id === "qdrant");
+		const chromadb = all.find((s) => s.id === "chromadb");
+
+		if (qdrant && chromadb) {
+			const warnings = checkCompatibility([qdrant, chromadb]);
+			expect(warnings.some((w) => w.message.includes("vector database"))).toBe(true);
+		}
+	});
+
+	it("warns about GPU services", () => {
+		const all = getAllServices();
+		const gpuService = all.find((s) => s.gpuRequired);
+
+		if (gpuService) {
+			const warnings = checkCompatibility([gpuService]);
+			expect(warnings.some((w) => w.message.includes("GPU"))).toBe(true);
+		}
+	});
+
+	it("returns no warnings for a single non-conflicting service", () => {
+		const redis = getServiceById("redis");
+		if (redis) {
+			const warnings = checkCompatibility([redis]);
+			expect(warnings.filter((w) => w.type === "compatibility" && !w.message.includes("GPU"))).toHaveLength(0);
+		}
+	});
+});

package/src/version-manager.ts

@@ -14,14 +14,21 @@ export function getImageReference(serviceId: string): string | undefined {
 	return `${svc.image}:${svc.imageTag}`;
 }
 
-/** Pin all service image tags in a resolved output (returns a copy) */
+/** Pin all service image tags to the registry-defined versions (returns a copy) */
 export function pinImageTags(resolved: ResolverOutput): ResolverOutput {
 	return {
 		...resolved,
-		services: resolved.services.map((s) => ({
-			...s,
-			definition: { ...s.definition },
-		})),
+		services: resolved.services.map((s) => {
+			const registryDef = getServiceById(s.definition.id);
+			const pinnedTag = registryDef?.imageTag ?? s.definition.imageTag;
+			return {
+				...s,
+				definition: {
+					...s.definition,
+					imageTag: pinnedTag,
+				},
+			};
+		}),
 	};
 }