@better-openclaw/core 1.0.7 → 1.0.9

package/src/services/definitions/stream-gateway.ts

@@ -0,0 +1,148 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const streamGatewayDefinition: ServiceDefinition = {
+	id: "stream-gateway",
+	name: "Stream Gateway",
+	description:
+		"NGINX-RTMP relay server that receives a local RTMP stream (e.g. from OBS in the desktop-environment) and fans it out to YouTube, Twitch, TikTok, and Telegram simultaneously. Also serves an HLS preview on HTTP for local viewing.",
+	category: "streaming",
+	icon: "📺",
+
+	image: "tiangolo/nginx-rtmp",
+	imageTag: "latest",
+	ports: [
+		{
+			host: 1935,
+			container: 1935,
+			description: "RTMP ingest (receives stream from OBS or ffmpeg)",
+			exposed: true,
+		},
+		{
+			host: 8080,
+			container: 8080,
+			description: "HTTP server for HLS preview and stats",
+			exposed: true,
+		},
+	],
+	volumes: [
+		{
+			name: "stream-gateway-hls",
+			containerPath: "/tmp/hls",
+			description: "HLS segment storage for live preview playback",
+		},
+	],
+	environment: [
+		{
+			key: "YOUTUBE_STREAM_KEY",
+			defaultValue: "",
+			secret: true,
+			description: "YouTube Live stream key (leave empty to skip YouTube relay)",
+			required: false,
+		},
+		{
+			key: "TWITCH_STREAM_KEY",
+			defaultValue: "",
+			secret: true,
+			description: "Twitch stream key (leave empty to skip Twitch relay)",
+			required: false,
+		},
+		{
+			key: "TIKTOK_STREAM_URL",
+			defaultValue: "",
+			secret: true,
+			description:
+				"Full TikTok RTMP URL from TikTok Studio (leave empty to skip TikTok relay)",
+			required: false,
+		},
+		{
+			key: "TELEGRAM_STREAM_URL",
+			defaultValue: "",
+			secret: true,
+			description:
+				"Full Telegram RTMPS URL including stream key (leave empty to skip Telegram relay)",
+			required: false,
+		},
+	],
+	healthcheck: {
+		test: "curl -sf http://localhost:8080/health || exit 1",
+		interval: "15s",
+		timeout: "5s",
+		retries: 3,
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	deploy: {
+		resources: {
+			limits: { cpus: "2.0", memory: "2G" },
+			reservations: { cpus: "0.5", memory: "512M" },
+		},
+	},
+
+	skills: [],
+	openclawEnvVars: [
+		{
+			key: "STREAM_GATEWAY_HOST",
+			defaultValue: "stream-gateway",
+			secret: false,
+			description: "Hostname of the stream-gateway container",
+			required: true,
+		},
+		{
+			key: "STREAM_GATEWAY_RTMP_PORT",
+			defaultValue: "1935",
+			secret: false,
+			description: "RTMP ingest port on the stream-gateway",
+			required: true,
+		},
+		{
+			key: "STREAM_GATEWAY_HLS_PORT",
+			defaultValue: "8080",
+			secret: false,
+			description: "HTTP port for HLS preview on the stream-gateway",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://github.com/tiangolo/nginx-rtmp-docker",
+	tags: [
+		"streaming",
+		"rtmp",
+		"hls",
+		"relay",
+		"youtube",
+		"twitch",
+		"tiktok",
+		"telegram",
+		"obs",
+		"nginx",
+	],
+	maturity: "experimental",
+
+	requires: [],
+	recommends: ["desktop-environment"],
+	conflictsWith: [],
+
+	removalWarning:
+		"⚠️ STREAMING KEYS REQUIRED: To relay to platforms you must provide at least one stream key. Without any keys configured the gateway will still accept RTMP input and serve HLS locally but nothing will be forwarded.",
+	minMemoryMB: 512,
+	gpuRequired: false,
+
+	nativeSupported: true,
+	nativeRecipes: [
+		{
+			platform: "linux",
+			installSteps: [
+				"command -v nginx >/dev/null 2>&1 || (command -v apt-get >/dev/null 2>&1 && sudo apt-get update -qq && sudo apt-get install -y -qq nginx libnginx-mod-rtmp ffmpeg)",
+				"command -v nginx >/dev/null 2>&1 || (command -v dnf >/dev/null 2>&1 && sudo dnf install -y nginx nginx-mod-rtmp ffmpeg)",
+			],
+			startCommand: "sudo systemctl start nginx",
+			stopCommand: "sudo systemctl stop nginx",
+			configPath: "/etc/nginx/nginx.conf",
+			configTemplate:
+				'# Generated for OpenClaw bare-metal\nworker_processes auto;\nrtmp_auto_push on;\n\nevents { worker_connections 1024; }\n\nrtmp {\n  server {\n    listen 1935;\n    chunk_size 4096;\n    application live {\n      live on;\n      record off;\n      hls on;\n      hls_path /tmp/hls;\n      hls_fragment 3;\n      hls_playlist_length 60;\n    }\n  }\n}\n\nhttp {\n  server {\n    listen 8080;\n    location /hls { types { application/vnd.apple.mpegurl m3u8; video/mp2t ts; } root /tmp; add_header Cache-Control no-cache; }\n    location /health { return 200 "OK"; }\n  }\n}\n',
+			systemdUnit: "nginx",
+		},
+	],
+};

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 {
@@ -120,4 +124,6 @@ export const SERVICE_CATEGORIES: CategoryInfo[] = [
 	{ id: "browser", name: "Browser Automation", icon: "🌐" },
 	{ id: "search", name: "Search", icon: "🔍" },
 	{ id: "communication", name: "Notifications", icon: "🔔" },
+	{ id: "desktop", name: "Desktop Environment", icon: "🖥️" },
+	{ id: "streaming", name: "Streaming & Relay", icon: "📺" },
 ];

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,
+				},
+			};
+		}),
 	};
 }