@better-openclaw/core 1.0.30 → 1.0.31

package/src/frameworks/frameworks.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+import { generate } from "../generate.js";
+import { getAllFrameworks, getFrameworkById } from "./registry.js";
+
+/**
+ * Smoke tests for all registered framework definitions.
+ *
+ * Each framework's buildGatewayService, generateConfig, and getBaseEnvVars
+ * should produce valid output when invoked through the generate() pipeline.
+ */
+
+describe("framework smoke tests via generate()", () => {
+	const primaryFrameworks = getAllFrameworks().filter((fw) => fw.canBePrimary);
+
+	for (const fw of primaryFrameworks) {
+		describe(`${fw.name} (${fw.id})`, () => {
+			it("generates a valid stack with this framework as primary", () => {
+				const result = generate({
+					projectName: `${fw.id}-test`,
+					services: ["redis"],
+					skillPacks: [],
+					proxy: "none",
+					gpu: false,
+					platform: "linux/amd64",
+					deployment: "local",
+					generateSecrets: true,
+					openclawVersion: "latest",
+					primaryFramework: fw.id,
+				});
+
+				expect(result.files).toHaveProperty("docker-compose.yml");
+				const composed = parse(result.files["docker-compose.yml"]!);
+				expect(composed.services).toBeDefined();
+
+				// Gateway service should exist with the framework's naming pattern
+				const gatewayKey = `${fw.id}-gateway`;
+				expect(composed.services).toHaveProperty(gatewayKey);
+			});
+
+			it("produces a docker-compose with the framework's network", () => {
+				const result = generate({
+					projectName: `${fw.id}-net-test`,
+					services: ["redis"],
+					skillPacks: [],
+					proxy: "none",
+					gpu: false,
+					platform: "linux/amd64",
+					deployment: "local",
+					generateSecrets: true,
+					openclawVersion: "latest",
+					primaryFramework: fw.id,
+				});
+
+				const composed = parse(result.files["docker-compose.yml"]!);
+				if (fw.networkName) {
+					expect(composed.networks).toHaveProperty(fw.networkName);
+				}
+			});
+
+			it("getBaseEnvVars returns an array", () => {
+				const envVars = fw.getBaseEnvVars({
+					generateSecrets: true,
+					domain: "example.com",
+				});
+				expect(envVars).toBeInstanceOf(Array);
+			});
+
+			it("getMandatoryServices returns an array", () => {
+				const mandatory = fw.getMandatoryServices();
+				expect(mandatory).toBeInstanceOf(Array);
+			});
+
+			it("getRecommendedServices returns an array", () => {
+				const recommended = fw.getRecommendedServices();
+				expect(recommended).toBeInstanceOf(Array);
+			});
+
+			it("getEnvSectionName returns a non-empty string", () => {
+				const section = fw.getEnvSectionName();
+				expect(typeof section).toBe("string");
+				expect(section.length).toBeGreaterThan(0);
+			});
+
+			it("getProviderEnvKeys returns an array", () => {
+				const keys = fw.getProviderEnvKeys();
+				expect(keys).toBeInstanceOf(Array);
+			});
+		});
+	}
+});
+
+describe("companion frameworks via generate()", () => {
+	const companionFrameworks = getAllFrameworks().filter((fw) => fw.canBeCompanion);
+
+	for (const fw of companionFrameworks) {
+		it(`${fw.name} can be added as companion`, () => {
+			const result = generate({
+				projectName: `companion-${fw.id}-test`,
+				services: ["redis"],
+				skillPacks: [],
+				proxy: "none",
+				gpu: false,
+				platform: "linux/amd64",
+				deployment: "local",
+				generateSecrets: true,
+				openclawVersion: "latest",
+				companionFrameworks: [fw.id],
+			});
+
+			const composed = parse(result.files["docker-compose.yml"]!);
+			expect(composed.services).toBeDefined();
+
+			// Companion should appear in compose
+			const companionKey = `${fw.id}-companion`;
+			expect(composed.services).toHaveProperty(companionKey);
+		});
+	}
+});

package/src/generators/cloud-init.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { generateCloudInit } from "./cloud-init.js";
+
+describe("generateCloudInit", () => {
+	const baseOptions = {
+		composeYaml: "version: '3'\nservices:\n  redis:\n    image: redis:7",
+		envContent: "REDIS_PASSWORD=secret123",
+		projectName: "my-stack",
+	};
+
+	it("generates valid cloud-init YAML starting with #cloud-config", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toMatch(/^#cloud-config/);
+	});
+
+	it("embeds the compose YAML content", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("redis:7");
+	});
+
+	it("embeds the env content with restrictive permissions", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("REDIS_PASSWORD=secret123");
+		expect(result).toContain('"0600"');
+	});
+
+	it("includes project name in the output", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("my-stack");
+	});
+
+	it("uses default gateway port 18789 when not specified", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("18789");
+	});
+
+	it("uses custom gateway port when specified", () => {
+		const result = generateCloudInit({ ...baseOptions, gatewayPort: 9999 });
+		expect(result).toContain("9999");
+		expect(result).not.toContain("18789");
+	});
+
+	it("includes Docker installation via convenience script", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("get.docker.com");
+	});
+
+	it("includes health check polling logic", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("RETRIES=");
+		expect(result).toContain("curl");
+	});
+
+	it("includes runcmd section", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("runcmd:");
+	});
+
+	it("includes final_message", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("final_message:");
+	});
+
+	it("includes required packages", () => {
+		const result = generateCloudInit(baseOptions);
+		expect(result).toContain("packages:");
+		expect(result).toContain("curl");
+		expect(result).toContain("git");
+	});
+});

package/src/generators/get-shit-done.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { generateGsdScripts } from "./get-shit-done.js";
+
+describe("generateGsdScripts", () => {
+	it("returns undefined when runtimes is undefined", () => {
+		expect(generateGsdScripts(undefined)).toBeUndefined();
+	});
+
+	it("returns undefined when runtimes is empty", () => {
+		expect(generateGsdScripts([])).toBeUndefined();
+	});
+
+	it("generates both sh and ps1 scripts", () => {
+		const result = generateGsdScripts(["claude" as any]);
+		expect(result).toBeDefined();
+		expect(result!.sh).toBeDefined();
+		expect(result!.ps1).toBeDefined();
+	});
+
+	it("sh script starts with shebang", () => {
+		const result = generateGsdScripts(["claude" as any]);
+		expect(result!.sh).toMatch(/^#!/);
+	});
+
+	it("includes runtime flags in sh script", () => {
+		const result = generateGsdScripts(["claude", "codex"] as any[]);
+		expect(result!.sh).toContain("--claude");
+		expect(result!.sh).toContain("--codex");
+	});
+
+	it("includes runtime flags in ps1 script", () => {
+		const result = generateGsdScripts(["claude", "codex"] as any[]);
+		expect(result!.ps1).toContain("--claude");
+		expect(result!.ps1).toContain("--codex");
+	});
+
+	it("uses npx to run get-shit-done", () => {
+		const result = generateGsdScripts(["claude"] as any[]);
+		expect(result!.sh).toContain("npx get-shit-done-cc@latest");
+		expect(result!.ps1).toContain("npx get-shit-done-cc@latest");
+	});
+
+	it("includes npx availability check", () => {
+		const result = generateGsdScripts(["claude"] as any[]);
+		expect(result!.sh).toContain("command -v npx");
+		expect(result!.ps1).toContain("Get-Command npx");
+	});
+
+	it("lists runtimes in output message", () => {
+		const result = generateGsdScripts(["claude", "codex"] as any[]);
+		expect(result!.sh).toContain("claude, codex");
+		expect(result!.ps1).toContain("claude, codex");
+	});
+});

package/src/generators/grafana.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+import { generateGrafanaConfig, generateGrafanaDashboard } from "./grafana.js";
+
+describe("generateGrafanaConfig", () => {
+	it("returns multiple config files", () => {
+		const files = generateGrafanaConfig();
+		expect(Object.keys(files).length).toBeGreaterThanOrEqual(3);
+	});
+
+	it("generates datasource provisioning YAML", () => {
+		const files = generateGrafanaConfig();
+		const dsFile = files["config/grafana/provisioning/datasources/prometheus.yml"];
+		expect(dsFile).toBeDefined();
+		const parsed = parse(dsFile!);
+		expect(parsed.datasources).toBeInstanceOf(Array);
+		expect(parsed.datasources[0].type).toBe("prometheus");
+		expect(parsed.datasources[0].isDefault).toBe(true);
+	});
+
+	it("generates dashboard provisioning YAML", () => {
+		const files = generateGrafanaConfig();
+		const dashFile = files["config/grafana/provisioning/dashboards/default.yml"];
+		expect(dashFile).toBeDefined();
+		const parsed = parse(dashFile!);
+		expect(parsed.providers).toBeInstanceOf(Array);
+		expect(parsed.providers[0].name).toContain("OpenClaw");
+	});
+
+	it("generates grafana.ini configuration", () => {
+		const files = generateGrafanaConfig();
+		const iniFile = files["config/grafana/grafana.ini"];
+		expect(iniFile).toBeDefined();
+		expect(iniFile).toContain("[server]");
+		expect(iniFile).toContain("[security]");
+		expect(iniFile).toContain("[alerting]");
+	});
+
+	it("disables anonymous auth", () => {
+		const files = generateGrafanaConfig();
+		const iniFile = files["config/grafana/grafana.ini"]!;
+		expect(iniFile).toContain("[auth.anonymous]");
+		expect(iniFile).toContain("enabled = false");
+	});
+});
+
+describe("generateGrafanaDashboard", () => {
+	it("returns valid JSON", () => {
+		const json = generateGrafanaDashboard();
+		const dashboard = JSON.parse(json);
+		expect(dashboard).toBeDefined();
+	});
+
+	it("includes expected panels", () => {
+		const dashboard = JSON.parse(generateGrafanaDashboard());
+		expect(dashboard.panels).toBeInstanceOf(Array);
+		expect(dashboard.panels.length).toBe(3);
+
+		const titles = dashboard.panels.map((p: { title: string }) => p.title);
+		expect(titles).toContain("Service Health");
+		expect(titles).toContain("Memory Usage");
+		expect(titles).toContain("Request Rate");
+	});
+
+	it("uses prometheus as datasource", () => {
+		const dashboard = JSON.parse(generateGrafanaDashboard());
+		for (const panel of dashboard.panels) {
+			expect(panel.datasource.type).toBe("prometheus");
+		}
+	});
+
+	it("has openclaw tag", () => {
+		const dashboard = JSON.parse(generateGrafanaDashboard());
+		expect(dashboard.tags).toContain("openclaw");
+	});
+
+	it("has correct schema version", () => {
+		const dashboard = JSON.parse(generateGrafanaDashboard());
+		expect(dashboard.schemaVersion).toBe(39);
+	});
+
+	it("panels have proper grid positions", () => {
+		const dashboard = JSON.parse(generateGrafanaDashboard());
+		for (const panel of dashboard.panels) {
+			expect(panel.gridPos).toBeDefined();
+			expect(panel.gridPos.h).toBeGreaterThan(0);
+			expect(panel.gridPos.w).toBeGreaterThan(0);
+		}
+	});
+});

package/src/generators/n8n-workflows.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import type { ResolverOutput } from "../types.js";
+import { generateN8nWorkflows } from "./n8n-workflows.js";
+
+function makeResolved(serviceIds: string[]): ResolverOutput {
+	return {
+		services: serviceIds.map((id) => ({
+			definition: {
+				id,
+				name: id.charAt(0).toUpperCase() + id.slice(1),
+				description: "",
+				icon: "",
+				category: "test",
+				image: `${id}:latest`,
+				ports: [],
+				volumes: [],
+				environment: [],
+				dependencies: [],
+				conflicts: [],
+				skills: [],
+				memoryMB: 256,
+				docsUrl: "",
+			},
+			addedBy: "user" as const,
+		})),
+		addedDependencies: [],
+		estimatedMemoryMB: 512,
+	} as unknown as ResolverOutput;
+}
+
+describe("generateN8nWorkflows", () => {
+	it("returns empty object when n8n is not in the stack", () => {
+		const result = generateN8nWorkflows(makeResolved(["redis", "postgresql"]));
+		expect(Object.keys(result)).toHaveLength(0);
+	});
+
+	it("generates workflow file when n8n is present", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n", "redis"]));
+		expect(result).toHaveProperty("n8n/workflows/openclaw-webhook-handler.json");
+	});
+
+	it("generates valid JSON workflow", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n"]));
+		const workflow = JSON.parse(result["n8n/workflows/openclaw-webhook-handler.json"]!);
+		expect(workflow).toBeDefined();
+		expect(workflow.name).toBe("OpenClaw Webhook Handler");
+	});
+
+	it("workflow has three nodes (webhook, process, respond)", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n", "redis"]));
+		const workflow = JSON.parse(result["n8n/workflows/openclaw-webhook-handler.json"]!);
+		expect(workflow.nodes).toHaveLength(3);
+
+		const types = workflow.nodes.map((n: { type: string }) => n.type);
+		expect(types).toContain("n8n-nodes-base.webhook");
+		expect(types).toContain("n8n-nodes-base.code");
+		expect(types).toContain("n8n-nodes-base.respondToWebhook");
+	});
+
+	it("workflow has correct connections", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n"]));
+		const workflow = JSON.parse(result["n8n/workflows/openclaw-webhook-handler.json"]!);
+		expect(workflow.connections).toHaveProperty("Webhook");
+		expect(workflow.connections).toHaveProperty("Process Payload");
+	});
+
+	it("workflow is not active by default", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n"]));
+		const workflow = JSON.parse(result["n8n/workflows/openclaw-webhook-handler.json"]!);
+		expect(workflow.active).toBe(false);
+	});
+
+	it("includes service names in the code node comment", () => {
+		const result = generateN8nWorkflows(makeResolved(["n8n", "redis", "postgresql"]));
+		const workflow = JSON.parse(result["n8n/workflows/openclaw-webhook-handler.json"]!);
+		const codeNode = workflow.nodes.find((n: { type: string }) => n.type === "n8n-nodes-base.code");
+		expect(codeNode.parameters.jsCode).toContain("Redis");
+		expect(codeNode.parameters.jsCode).toContain("Postgresql");
+	});
+});

package/src/generators/openclaw-install-script.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { generateOpenclawInstallScript } from "./openclaw-install-script.js";
+
+describe("generateOpenclawInstallScript", () => {
+	it("generates both sh and ps1 scripts", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test-project" });
+		expect(files).toHaveProperty("scripts/install-openclaw.sh");
+		expect(files).toHaveProperty("scripts/install-openclaw.ps1");
+	});
+
+	it("sh script starts with shebang", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test" });
+		expect(files["scripts/install-openclaw.sh"]).toMatch(/^#!/);
+	});
+
+	it("sh script uses set -euo pipefail", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test" });
+		expect(files["scripts/install-openclaw.sh"]).toContain("set -euo pipefail");
+	});
+
+	it("includes project name in scripts", () => {
+		const files = generateOpenclawInstallScript({ projectName: "my-project" });
+		expect(files["scripts/install-openclaw.sh"]).toContain("my-project");
+		expect(files["scripts/install-openclaw.ps1"]).toContain("my-project");
+	});
+
+	it("uses official installer URL", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test" });
+		expect(files["scripts/install-openclaw.sh"]).toContain("openclaw.ai/install.sh");
+	});
+
+	it("ps1 script checks for WSL", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test" });
+		expect(files["scripts/install-openclaw.ps1"]).toContain("wsl");
+	});
+
+	it("includes next steps in output", () => {
+		const files = generateOpenclawInstallScript({ projectName: "test" });
+		expect(files["scripts/install-openclaw.sh"]).toContain("Next steps");
+		expect(files["scripts/install-openclaw.ps1"]).toContain("Next steps");
+	});
+});

package/src/generators/postgres-init.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import type { ResolverOutput } from "../types.js";
+import { generatePostgresInit, getDbRequirements } from "./postgres-init.js";
+
+function makeResolved(serviceIds: string[]): ResolverOutput {
+	return {
+		services: serviceIds.map((id) => ({
+			definition: {
+				id,
+				name: id.charAt(0).toUpperCase() + id.slice(1),
+				description: "",
+				icon: "",
+				category: "test",
+				image: `${id}:latest`,
+				ports: [],
+				volumes: [],
+				environment: [],
+				dependencies: [],
+				conflicts: [],
+				skills: [],
+				memoryMB: 256,
+				docsUrl: "",
+			},
+			addedBy: "user" as const,
+		})),
+		addedDependencies: [],
+		estimatedMemoryMB: 512,
+	} as unknown as ResolverOutput;
+}
+
+describe("getDbRequirements", () => {
+	it("returns empty array when no services need a DB", () => {
+		const resolved = makeResolved(["redis", "minio"]);
+		expect(getDbRequirements(resolved)).toEqual([]);
+	});
+
+	it("returns requirements for n8n", () => {
+		const resolved = makeResolved(["n8n", "redis"]);
+		const reqs = getDbRequirements(resolved);
+		expect(reqs).toHaveLength(1);
+		expect(reqs[0]).toEqual({
+			serviceId: "n8n",
+			serviceName: "N8n",
+			dbName: "n8n",
+			dbUser: "n8n",
+			passwordEnvVar: "N8N_DB_PASSWORD",
+		});
+	});
+
+	it("returns requirements for multiple services", () => {
+		const resolved = makeResolved(["n8n", "outline", "postiz", "redis"]);
+		const reqs = getDbRequirements(resolved);
+		expect(reqs).toHaveLength(3);
+		const ids = reqs.map((r) => r.serviceId);
+		expect(ids).toContain("n8n");
+		expect(ids).toContain("outline");
+		expect(ids).toContain("postiz");
+	});
+});
+
+describe("generatePostgresInit", () => {
+	it("returns null when PostgreSQL is not in the stack", () => {
+		const resolved = makeResolved(["n8n", "redis"]);
+		expect(generatePostgresInit(resolved)).toBeNull();
+	});
+
+	it("returns null when PostgreSQL is present but no services need DBs", () => {
+		const resolved = makeResolved(["postgresql", "redis", "minio"]);
+		expect(generatePostgresInit(resolved)).toBeNull();
+	});
+
+	it("generates init script when PostgreSQL and DB-needing services are present", () => {
+		const resolved = makeResolved(["postgresql", "n8n"]);
+		const script = generatePostgresInit(resolved);
+		expect(script).not.toBeNull();
+		expect(script).toContain("#!/bin/bash");
+		expect(script).toContain("create_db_and_user");
+		expect(script).toContain('"n8n"');
+		expect(script).toContain("N8N_DB_PASSWORD");
+	});
+
+	it("includes all services that need DBs", () => {
+		const resolved = makeResolved(["postgresql", "n8n", "outline", "dify"]);
+		const script = generatePostgresInit(resolved)!;
+		expect(script).toContain('"n8n"');
+		expect(script).toContain('"outline"');
+		expect(script).toContain('"dify"');
+	});
+
+	it("uses environment variable substitution for passwords (not literals)", () => {
+		const resolved = makeResolved(["postgresql", "n8n"]);
+		const script = generatePostgresInit(resolved)!;
+		// Passwords should be referenced as env vars, not hardcoded
+		expect(script).toContain("${N8N_DB_PASSWORD:-$POSTGRES_PASSWORD}");
+	});
+
+	it("script uses psql with ON_ERROR_STOP", () => {
+		const resolved = makeResolved(["postgresql", "n8n"]);
+		const script = generatePostgresInit(resolved)!;
+		expect(script).toContain("ON_ERROR_STOP=1");
+	});
+
+	it("script creates user with IF NOT EXISTS check", () => {
+		const resolved = makeResolved(["postgresql", "n8n"]);
+		const script = generatePostgresInit(resolved)!;
+		expect(script).toContain("IF NOT EXISTS");
+		expect(script).toContain("CREATE ROLE");
+	});
+
+	it("includes service names in summary line", () => {
+		const resolved = makeResolved(["postgresql", "n8n", "outline"]);
+		const script = generatePostgresInit(resolved)!;
+		expect(script).toContain("N8n");
+		expect(script).toContain("Outline");
+	});
+});

package/src/generators/prometheus.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+import { generate } from "../generate.js";
+import type { ResolverOutput } from "../types.js";
+import { generatePrometheusConfig } from "./prometheus.js";
+
+function makeResolved(serviceIds: string[]): ResolverOutput {
+	return {
+		services: serviceIds.map((id) => ({
+			definition: {
+				id,
+				name: id.charAt(0).toUpperCase() + id.slice(1),
+				description: "",
+				icon: "📦",
+				category: "test",
+				image: `${id}:latest`,
+				ports: [],
+				volumes: [],
+				environment: [],
+				dependencies: [],
+				conflicts: [],
+				skills: [],
+				memoryMB: 256,
+				docsUrl: "",
+			},
+			addedBy: "user" as const,
+		})),
+		addedDependencies: [],
+		estimatedMemoryMB: 512,
+	} as unknown as ResolverOutput;
+}
+
+describe("generatePrometheusConfig", () => {
+	it("always includes prometheus self-monitoring", () => {
+		const config = generatePrometheusConfig(makeResolved(["redis"]));
+		expect(config).toContain('job_name: "prometheus"');
+		expect(config).toContain("localhost:9090");
+	});
+
+	it("includes scrape config for redis", () => {
+		const config = generatePrometheusConfig(makeResolved(["redis"]));
+		expect(config).toContain('job_name: "redis"');
+		expect(config).toContain("redis:9121");
+	});
+
+	it("includes scrape config for postgresql", () => {
+		const config = generatePrometheusConfig(makeResolved(["postgresql"]));
+		expect(config).toContain('job_name: "postgresql"');
+		expect(config).toContain("postgresql:9187");
+	});
+
+	it("includes scrape configs for multiple services", () => {
+		const config = generatePrometheusConfig(makeResolved(["redis", "n8n", "minio"]));
+		expect(config).toContain('job_name: "redis"');
+		expect(config).toContain('job_name: "n8n"');
+		expect(config).toContain('job_name: "minio"');
+	});
+
+	it("skips services without known metrics endpoints", () => {
+		const config = generatePrometheusConfig(makeResolved(["ffmpeg"]));
+		expect(config).not.toContain('job_name: "ffmpeg"');
+	});
+
+	it("does not duplicate prometheus job", () => {
+		const config = generatePrometheusConfig(makeResolved(["prometheus", "redis"]));
+		const matches = config.match(/job_name: "prometheus"/g);
+		expect(matches).toHaveLength(1);
+	});
+
+	it("always includes openclaw gateway metrics", () => {
+		const config = generatePrometheusConfig(makeResolved(["redis"]));
+		expect(config).toContain('job_name: "openclaw-gateway"');
+		expect(config).toContain("openclaw:18789");
+	});
+
+	it("is valid YAML", () => {
+		const config = generatePrometheusConfig(makeResolved(["redis", "postgresql"]));
+		const parsed = parse(config);
+		expect(parsed).toBeDefined();
+		expect(parsed.global).toBeDefined();
+		expect(parsed.scrape_configs).toBeInstanceOf(Array);
+	});
+
+	it("sets correct metrics paths per service", () => {
+		const config = generatePrometheusConfig(makeResolved(["minio"]));
+		expect(config).toContain("/minio/v2/metrics/cluster");
+	});
+});
+
+describe("prometheus via generate()", () => {
+	it("generates prometheus config when monitoring is enabled", () => {
+		const result = generate({
+			projectName: "prom-test",
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			deployment: "local",
+			generateSecrets: true,
+			openclawVersion: "latest",
+			monitoring: true,
+		});
+		expect(result.files).toHaveProperty("prometheus/prometheus.yml");
+		const promConfig = parse(result.files["prometheus/prometheus.yml"]!);
+		expect(promConfig.scrape_configs.length).toBeGreaterThan(0);
+	});
+});