@better-openclaw/core 1.0.0

package/src/bare-metal-partition.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import {
+	partitionBareMetal,
+	platformToNativePlatform,
+	resolvedWithOnlyServices,
+} from "./bare-metal-partition.js";
+import { resolve } from "./resolver.js";
+
+describe("bare-metal partition", () => {
+	it("platformToNativePlatform maps platform to native", () => {
+		expect(platformToNativePlatform("linux/amd64")).toBe("linux");
+		expect(platformToNativePlatform("linux/arm64")).toBe("linux");
+		expect(platformToNativePlatform("windows/amd64")).toBe("windows");
+		expect(platformToNativePlatform("macos/arm64")).toBe("macos");
+	});
+
+	it("partitions redis as native on Linux when redis has native recipe", () => {
+		const resolved = resolve({
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			monitoring: false,
+		});
+		const result = partitionBareMetal(resolved, "linux/amd64");
+		expect(result.nativeIds.has("redis")).toBe(true);
+		expect(result.nativeServices.length).toBe(1);
+		expect(result.nativeServices[0].definition.id).toBe("redis");
+		expect(result.dockerOnlyServices.length).toBe(0);
+	});
+
+	it("partitions n8n as Docker-only (no native recipe)", () => {
+		const resolved = resolve({
+			services: ["n8n"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			monitoring: false,
+		});
+		const result = partitionBareMetal(resolved, "linux/amd64");
+		expect(result.nativeIds.has("n8n")).toBe(false);
+		expect(result.nativeServices.length).toBe(0);
+		expect(result.dockerOnlyServices.length).toBeGreaterThanOrEqual(1);
+		expect(result.dockerOnlyServices.some((s) => s.definition.id === "n8n")).toBe(true);
+	});
+
+	it("resolvedWithOnlyServices filters to given service list", () => {
+		const resolved = resolve({
+			services: ["redis", "n8n"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			monitoring: false,
+		});
+		const partition = partitionBareMetal(resolved, "linux/amd64");
+		const filtered = resolvedWithOnlyServices(resolved, partition.dockerOnlyServices);
+		expect(filtered.services.every((s) => s.definition.id !== "redis")).toBe(true);
+		expect(filtered.services.some((s) => s.definition.id === "n8n")).toBe(true);
+	});
+});

package/src/bare-metal-partition.ts

@@ -0,0 +1,64 @@
+import type { NativePlatform, Platform, ResolvedService, ResolverOutput } from "./types.js";
+
+/**
+ * Maps Platform (e.g. linux/amd64) to NativePlatform (linux, windows, macos).
+ */
+export function platformToNativePlatform(platform: Platform): NativePlatform {
+	if (platform.startsWith("linux/")) return "linux";
+	if (platform.startsWith("windows/")) return "windows";
+	if (platform.startsWith("macos/")) return "macos";
+	return "linux";
+}
+
+export interface BareMetalPartitionResult {
+	nativeServices: ResolvedService[];
+	dockerOnlyServices: ResolvedService[];
+	nativeIds: Set<string>;
+}
+
+/**
+ * Partitions resolved services into native (run on host via scripts) vs Docker-only.
+ * Gateway and CLI are never native; services with nativeSupported and a matching
+ * nativeRecipe for the platform go to native, rest to Docker.
+ */
+export function partitionBareMetal(
+	resolved: ResolverOutput,
+	platform: Platform,
+): BareMetalPartitionResult {
+	const nativePlatform = platformToNativePlatform(platform);
+	const nativeServices: ResolvedService[] = [];
+	const dockerOnlyServices: ResolvedService[] = [];
+	const nativeIds = new Set<string>();
+
+	for (const entry of resolved.services) {
+		const def = entry.definition;
+		const hasNativeRecipe =
+			def.nativeSupported === true &&
+			def.nativeRecipes?.length &&
+			def.nativeRecipes.some((r) => r.platform === nativePlatform);
+
+		if (hasNativeRecipe) {
+			nativeServices.push(entry);
+			nativeIds.add(def.id);
+		} else {
+			dockerOnlyServices.push(entry);
+		}
+	}
+
+	return { nativeServices, dockerOnlyServices, nativeIds };
+}
+
+/**
+ * Returns a new ResolverOutput containing only the given service list (same order).
+ * Used to build compose for Docker-only subset when bare-metal has native services.
+ */
+export function resolvedWithOnlyServices(
+	resolved: ResolverOutput,
+	services: ResolvedService[],
+): ResolverOutput {
+	const idSet = new Set(services.map((s) => s.definition.id));
+	return {
+		...resolved,
+		services: resolved.services.filter((s) => idSet.has(s.definition.id)),
+	};
+}

package/src/composer.snapshot.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { composeMultiFile } from "./composer.js";
+import { resolve } from "./resolver.js";
+
+function generateForPreset(services: string[], skillPacks: string[] = []) {
+	const resolved = resolve({ services, skillPacks });
+	return composeMultiFile(resolved, {
+		projectName: "test-stack",
+		proxy: "none",
+		gpu: false,
+		platform: "linux/amd64",
+		deployment: "local",
+		openclawVersion: "latest",
+	});
+}
+
+describe("compose snapshot tests", () => {
+	it("minimal preset (redis only)", () => {
+		const result = generateForPreset(["redis"]);
+		expect(result.files["docker-compose.yml"]).toMatchSnapshot();
+	});
+
+	it("creator preset (ffmpeg + remotion + minio + redis)", () => {
+		const result = generateForPreset(["ffmpeg", "remotion", "minio", "redis"], ["video-creator"]);
+		expect(result.files["docker-compose.yml"]).toMatchSnapshot();
+		if (result.files["docker-compose.media.yml"]) {
+			expect(result.files["docker-compose.media.yml"]).toMatchSnapshot();
+		}
+	});
+
+	it("researcher preset (qdrant + searxng + browserless + redis)", () => {
+		const result = generateForPreset(
+			["qdrant", "searxng", "browserless", "redis"],
+			["research-agent"],
+		);
+		expect(result.files["docker-compose.yml"]).toMatchSnapshot();
+	});
+
+	it("devops preset (n8n + postgresql + redis + monitoring)", () => {
+		const result = generateForPreset(
+			["n8n", "postgresql", "redis", "uptime-kuma", "grafana", "prometheus"],
+			["dev-ops"],
+		);
+		expect(result.files["docker-compose.yml"]).toMatchSnapshot();
+		if (result.files["docker-compose.monitoring.yml"]) {
+			expect(result.files["docker-compose.monitoring.yml"]).toMatchSnapshot();
+		}
+	});
+
+	it("full preset (many services)", () => {
+		const result = generateForPreset([
+			"redis",
+			"postgresql",
+			"qdrant",
+			"n8n",
+			"ffmpeg",
+			"remotion",
+			"minio",
+			"caddy",
+			"browserless",
+			"searxng",
+			"meilisearch",
+			"uptime-kuma",
+			"grafana",
+			"prometheus",
+			"ollama",
+			"whisper",
+			"gotify",
+		]);
+		expect(result.files["docker-compose.yml"]).toMatchSnapshot();
+		expect(result.profiles.length).toBeGreaterThan(0);
+		// Verify multiple compose files were created
+		expect(Object.keys(result.files).length).toBeGreaterThan(1);
+	});
+
+	it("multi-file output has correct profile assignments", () => {
+		const result = generateForPreset(["redis", "ollama", "open-webui", "grafana", "prometheus"]);
+		// AI services should be in the ai profile file
+		if (result.files["docker-compose.ai.yml"]) {
+			expect(result.files["docker-compose.ai.yml"]).toContain("profiles:");
+		}
+		// Monitoring should be in the monitoring profile file
+		if (result.files["docker-compose.monitoring.yml"]) {
+			expect(result.files["docker-compose.monitoring.yml"]).toContain("profiles:");
+		}
+	});
+});

package/src/composer.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+import { compose } from "./composer.js";
+import { resolve } from "./resolver.js";
+import type { ComposeOptions, ResolverOutput } from "./types.js";
+
+const defaultOptions: ComposeOptions = {
+	projectName: "test-project",
+	proxy: "none",
+	gpu: false,
+	platform: "linux/amd64",
+	deployment: "local",
+	openclawVersion: "latest",
+};
+
+describe("compose", () => {
+	it("generates minimal stack with just OpenClaw gateway when no companions", () => {
+		const resolved = resolve({ services: [], skillPacks: [] });
+		const yaml = compose(resolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// Should have the gateway service
+		expect(parsed.services).toHaveProperty("openclaw-gateway");
+		expect(parsed.services["openclaw-gateway"].image).toContain("ghcr.io/openclaw/openclaw");
+
+		// Gateway should have core environment
+		expect(parsed.services["openclaw-gateway"].environment.HOME).toBe("/home/node");
+		expect(parsed.services["openclaw-gateway"].environment.TERM).toBe("xterm-256color");
+
+		// Gateway uses bind-mount volumes (not named volumes in top-level volumes section)
+		const gwVolumes = parsed.services["openclaw-gateway"].volumes as string[];
+		expect(gwVolumes.some((v: string) => v.includes(".openclaw"))).toBe(true);
+
+		// Should have network
+		expect(parsed.networks).toHaveProperty("openclaw-network");
+		expect(parsed.networks["openclaw-network"].driver).toBe("bridge");
+
+		// Should have CLI companion service
+		expect(parsed.services).toHaveProperty("openclaw-cli");
+
+		// Gateway should have no depends_on (no companions)
+		expect(parsed.services["openclaw-gateway"]).not.toHaveProperty("depends_on");
+
+		// Gateway should have restart policy
+		expect(parsed.services["openclaw-gateway"].restart).toBe("unless-stopped");
+	});
+
+	it("generates Redis companion with proper gateway depends_on", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+		const yaml = compose(resolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// Should have gateway and redis services
+		expect(parsed.services).toHaveProperty("openclaw-gateway");
+		expect(parsed.services).toHaveProperty("redis");
+
+		// Redis service should have correct image
+		expect(parsed.services.redis.image).toBe("redis:7-alpine");
+
+		// Gateway depends_on should include redis with service_healthy (redis has healthcheck)
+		expect(parsed.services["openclaw-gateway"].depends_on).toHaveProperty("redis");
+		expect(parsed.services["openclaw-gateway"].depends_on.redis.condition).toBe("service_healthy");
+
+		// Redis should have a healthcheck
+		expect(parsed.services.redis.healthcheck).toBeDefined();
+		expect(parsed.services.redis.healthcheck.test).toContain("redis-cli ping");
+
+		// Redis should have restart policy
+		expect(parsed.services.redis.restart).toBe("unless-stopped");
+
+		// Redis should be on openclaw-network
+		expect(parsed.services.redis.networks).toContain("openclaw-network");
+
+		// Gateway environment should include redis-related openclawEnvVars
+		expect(parsed.services["openclaw-gateway"].environment).toHaveProperty("REDIS_HOST");
+		expect(parsed.services["openclaw-gateway"].environment.REDIS_HOST).toBe("redis");
+	});
+
+	it("generates parseable YAML for a multi-service stack", () => {
+		const resolved = resolve({ services: ["redis", "n8n"], skillPacks: [] });
+		const yaml = compose(resolved, defaultOptions);
+
+		// Should not throw when parsing
+		expect(() => parse(yaml)).not.toThrow();
+
+		const parsed = parse(yaml);
+		expect(parsed).toHaveProperty("services");
+		expect(parsed).toHaveProperty("volumes");
+		expect(parsed).toHaveProperty("networks");
+
+		// Should have gateway + redis + n8n + postgresql (n8n requires postgresql)
+		expect(parsed.services).toHaveProperty("openclaw-gateway");
+		expect(parsed.services).toHaveProperty("redis");
+		expect(parsed.services).toHaveProperty("n8n");
+		expect(parsed.services).toHaveProperty("postgresql");
+	});
+
+	it("includes all service volumes in top-level volumes section", () => {
+		const resolved = resolve({ services: ["redis", "n8n"], skillPacks: [] });
+		const yaml = compose(resolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// Collect all volume names from all resolved services
+		const serviceVolumeNames = new Set<string>();
+		for (const rs of resolved.services) {
+			for (const vol of rs.definition.volumes) {
+				serviceVolumeNames.add(vol.name);
+			}
+		}
+
+		// All service volumes must appear in top-level volumes
+		for (const volName of serviceVolumeNames) {
+			expect(parsed.volumes).toHaveProperty(volName);
+		}
+
+		// Gateway uses bind-mount volumes (not in top-level volumes section)
+		const gwVols = parsed.services["openclaw-gateway"].volumes as string[];
+		expect(gwVols.some((v: string) => v.includes(".openclaw"))).toBe(true);
+	});
+
+	it("includes GPU passthrough when gpu=true and service requires it", () => {
+		const resolved = resolve({ services: ["ollama"], skillPacks: [] });
+
+		// Modify resolved output to simulate a GPU-required service
+		const gpuResolved: ResolverOutput = {
+			...resolved,
+			services: resolved.services.map((s) => ({
+				...s,
+				definition: { ...s.definition, gpuRequired: true },
+			})),
+		};
+
+		const yaml = compose(gpuResolved, { ...defaultOptions, gpu: true });
+		const parsed = parse(yaml);
+
+		// Ollama service should have GPU device reservation
+		const ollamaService = parsed.services.ollama;
+		expect(ollamaService.deploy).toBeDefined();
+		expect(ollamaService.deploy.resources.reservations.devices).toEqual([
+			{
+				driver: "nvidia",
+				count: "all",
+				capabilities: ["gpu"],
+			},
+		]);
+	});
+
+	it("does not include GPU passthrough when gpu=false", () => {
+		const resolved = resolve({ services: ["ollama"], skillPacks: [] });
+
+		// Even if service requires GPU, gpu option is false
+		const gpuResolved: ResolverOutput = {
+			...resolved,
+			services: resolved.services.map((s) => ({
+				...s,
+				definition: { ...s.definition, gpuRequired: true },
+			})),
+		};
+
+		const yaml = compose(gpuResolved, { ...defaultOptions, gpu: false });
+		const parsed = parse(yaml);
+
+		// Should NOT have deploy with GPU devices
+		const ollamaService = parsed.services.ollama;
+		expect(ollamaService.deploy?.resources?.reservations?.devices).toBeUndefined();
+	});
+
+	it("does not map internal-only ports to host", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+
+		// Modify redis to have an internal-only port
+		const modifiedResolved: ResolverOutput = {
+			...resolved,
+			services: resolved.services.map((s) => ({
+				...s,
+				definition: {
+					...s.definition,
+					ports: [
+						...s.definition.ports,
+						{ host: 16379, container: 16379, description: "Redis cluster bus", exposed: false },
+					],
+				},
+			})),
+		};
+
+		const yaml = compose(modifiedResolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// Should only have the exposed port, not the internal one
+		const redisPorts = parsed.services.redis.ports;
+		expect(redisPorts).toHaveLength(1);
+		expect(redisPorts[0]).toContain("6379");
+		expect(redisPorts[0]).not.toContain("16379");
+	});
+
+	it("uses service_started condition for services without healthcheck", () => {
+		const resolved = resolve({ services: ["minio"], skillPacks: [] });
+
+		const yaml = compose(resolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// Minio may or may not have a healthcheck – the gateway depends_on
+		// condition should reflect the definition accurately
+		const gatewayDeps = parsed.services["openclaw-gateway"].depends_on;
+		for (const [id, dep] of Object.entries(gatewayDeps)) {
+			const svc = resolved.services.find((s) => s.definition.id === id);
+			if (svc?.definition.healthcheck) {
+				expect((dep as { condition: string }).condition).toBe("service_healthy");
+			} else {
+				expect((dep as { condition: string }).condition).toBe("service_started");
+			}
+		}
+	});
+
+	it("gateway is always the first service in the output", () => {
+		const resolved = resolve({ services: ["redis", "ollama"], skillPacks: [] });
+		const yaml = compose(resolved, defaultOptions);
+		const parsed = parse(yaml);
+
+		// First key in services should be openclaw-gateway
+		const serviceKeys = Object.keys(parsed.services);
+		expect(serviceKeys[0]).toBe("openclaw-gateway");
+	});
+});