@better-openclaw/core 1.0.0

package/src/index.ts

@@ -0,0 +1,118 @@
+// ─── Schemas ────────────────────────────────────────────────────────────────
+
+// ─── Core Engines ───────────────────────────────────────────────────────────
+export {
+	partitionBareMetal,
+	platformToNativePlatform,
+	resolvedWithOnlyServices,
+} from "./bare-metal-partition.js";
+export type { ComposeResult } from "./composer.js";
+export { compose, composeMultiFile } from "./composer.js";
+export { generate } from "./generate.js";
+export { generateCaddyfile } from "./generators/caddy.js";
+export type { EnvVarGroup } from "./generators/env.js";
+export { generateEnvFiles, getStructuredEnvVars } from "./generators/env.js";
+export { generateGrafanaConfig, generateGrafanaDashboard } from "./generators/grafana.js";
+export { generateN8nWorkflows } from "./generators/n8n-workflows.js";
+export { generatePostgresInit, getDbRequirements } from "./generators/postgres-init.js";
+export { generatePrometheusConfig } from "./generators/prometheus.js";
+export { generateReadme } from "./generators/readme.js";
+export { generateScripts } from "./generators/scripts.js";
+export { generateSkillFiles } from "./generators/skills.js";
+// ─── Presets ────────────────────────────────────────────────────────────────
+export { getAllPresets, getPresetById, presetRegistry } from "./presets/registry.js";
+export { resolve } from "./resolver.js";
+export {
+	AddedDependencySchema,
+	ApiErrorSchema,
+	ComposeOptionsSchema,
+	DeploymentTargetSchema,
+	DeploymentTypeSchema,
+	DeploySchema,
+	EnvVariableSchema,
+	ErrorSchema,
+	GenerationInputSchema,
+	HealthCheckSchema,
+	MaturitySchema,
+	NativePlatformSchema,
+	NativeRecipeSchema,
+	OutputFormatSchema,
+	PlatformSchema,
+	PortMappingSchema,
+	PresetSchema,
+	ProxyTypeSchema,
+	ResolvedServiceSchema,
+	ResolverOutputSchema,
+	ResourceLimitsSchema,
+	RestartPolicySchema,
+	ServiceCategorySchema,
+	ServiceDefinitionSchema,
+	SkillBindingSchema,
+	SkillPackSchema,
+	ValidateRequestSchema,
+	ValidateResponseSchema,
+	VolumeMappingSchema,
+	WarningSchema,
+} from "./schema.js";
+// ─── Service Registry ───────────────────────────────────────────────────────
+export {
+	getAllServices,
+	getServiceById,
+	getServicesByCategory,
+	serviceRegistry,
+} from "./services/registry.js";
+// ─── Skill Packs ────────────────────────────────────────────────────────────
+export {
+	getAllSkillPacks,
+	getCompatibleSkillPacks,
+	getSkillPackById,
+	skillPackRegistry,
+} from "./skills/registry.js";
+// ─── Types ──────────────────────────────────────────────────────────────────
+export type {
+	AddedDependency,
+	ApiError,
+	CategoryInfo,
+	ComposeOptions,
+	Deploy,
+	DeploymentTarget,
+	DeploymentType,
+	EnvVariable,
+	GeneratedFiles,
+	GenerationInput,
+	GenerationMetadata,
+	GenerationResult,
+	HealthCheck,
+	Maturity,
+	NativePlatform,
+	NativeRecipe,
+	OutputFormat,
+	Platform,
+	PortMapping,
+	Preset,
+	ProxyType,
+	ResolvedService,
+	ResolverError,
+	ResolverInput,
+	ResolverOutput,
+	ResourceLimits,
+	RestartPolicy,
+	ServiceCategory,
+	ServiceDefinition,
+	SkillBinding,
+	SkillPack,
+	ValidateRequest,
+	ValidateResponse,
+	VolumeMapping,
+	Warning,
+} from "./types.js";
+export { SERVICE_CATEGORIES } from "./types.js";
+export { validate } from "./validator.js";
+
+// ─── Version Manager ────────────────────────────────────────────────────────
+export {
+	checkCompatibility,
+	getImageReference,
+	getImageTag,
+	pinImageTags,
+} from "./version-manager.js";

package/src/presets/registry.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { getAllPresets, getPresetById } from "./registry.js";
+
+describe("preset registry", () => {
+	it("getPresetById returns undefined for unknown id", () => {
+		expect(getPresetById("unknown")).toBeUndefined();
+	});
+
+	it("getPresetById returns La Suite Meet preset with correct services", () => {
+		const preset = getPresetById("lasuite-meet");
+		expect(preset).toBeDefined();
+		expect(preset!.id).toBe("lasuite-meet");
+		expect(preset!.name).toBe("La Suite Meet");
+		expect(preset!.services).toEqual([
+			"postgresql",
+			"redis",
+			"livekit",
+			"lasuite-meet-backend",
+			"lasuite-meet-frontend",
+			"lasuite-meet-agents",
+		]);
+		expect(preset!.skillPacks).toEqual([]);
+		expect(preset!.estimatedMemoryMB).toBe(2048);
+	});
+
+	it("getAllPresets includes La Suite Meet", () => {
+		const all = getAllPresets();
+		const lasuite = all.find((p) => p.id === "lasuite-meet");
+		expect(lasuite).toBeDefined();
+		expect(lasuite!.name).toBe("La Suite Meet");
+	});
+});

package/src/presets/registry.ts

@@ -0,0 +1,126 @@
+import type { Preset } from "../types.js";
+
+const presets: Preset[] = [
+	{
+		id: "minimal",
+		name: "Minimal",
+		description: "OpenClaw + Redis for caching and session management",
+		services: ["redis"],
+		skillPacks: [],
+		estimatedMemoryMB: 1024,
+	},
+	{
+		id: "creator",
+		name: "Creator",
+		description: "Full media creation stack with FFmpeg, Remotion, and MinIO storage",
+		services: ["ffmpeg", "remotion", "minio", "redis"],
+		skillPacks: ["video-creator"],
+		estimatedMemoryMB: 2048,
+	},
+	{
+		id: "researcher",
+		name: "Researcher",
+		description: "Research agent with vector search, web scraping, and meta search",
+		services: ["qdrant", "searxng", "browserless", "redis"],
+		skillPacks: ["research-agent"],
+		estimatedMemoryMB: 2560,
+	},
+	{
+		id: "devops",
+		name: "DevOps",
+		description: "Full monitoring and automation stack with n8n, Grafana, and Uptime Kuma",
+		services: ["n8n", "postgresql", "redis", "uptime-kuma", "grafana", "prometheus"],
+		skillPacks: ["dev-ops"],
+		estimatedMemoryMB: 3072,
+	},
+	{
+		id: "full",
+		name: "Full Stack",
+		description: "Everything enabled — all services and skill packs",
+		services: [
+			"redis",
+			"postgresql",
+			"qdrant",
+			"n8n",
+			"ffmpeg",
+			"remotion",
+			"minio",
+			"caddy",
+			"browserless",
+			"searxng",
+			"meilisearch",
+			"uptime-kuma",
+			"grafana",
+			"prometheus",
+			"ollama",
+			"whisper",
+			"gotify",
+		],
+		skillPacks: [
+			"video-creator",
+			"research-agent",
+			"social-media",
+			"dev-ops",
+			"knowledge-base",
+			"local-ai",
+		],
+		estimatedMemoryMB: 8192,
+	},
+	{
+		id: "content-creator",
+		name: "Content Creator",
+		description: "Social media scheduling with Postiz, media processing, and analytics",
+		services: ["postiz", "ffmpeg", "minio", "redis", "postgresql", "umami"],
+		skillPacks: ["content-creator"],
+		estimatedMemoryMB: 2048,
+	},
+	{
+		id: "ai-playground",
+		name: "AI Playground",
+		description: "Local AI stack with Ollama, Open WebUI, LiteLLM gateway, and document chat",
+		services: ["ollama", "open-webui", "litellm", "anything-llm", "redis"],
+		skillPacks: ["ai-playground"],
+		estimatedMemoryMB: 4096,
+	},
+	{
+		id: "coding-team",
+		name: "Coding Team",
+		description: "AI development environment with coding agents, Git, and browser IDE",
+		services: ["claude-code", "opencode", "gitea", "code-server", "redis"],
+		skillPacks: ["coding-team"],
+		estimatedMemoryMB: 2560,
+	},
+	{
+		id: "lasuite-meet",
+		name: "La Suite Meet",
+		description: "Open-source video conferencing from La Suite numérique (Django + LiveKit)",
+		services: [
+			"postgresql",
+			"redis",
+			"livekit",
+			"lasuite-meet-backend",
+			"lasuite-meet-frontend",
+			"lasuite-meet-agents",
+		],
+		skillPacks: [],
+		estimatedMemoryMB: 2048,
+	},
+];
+
+const presetMap = new Map<string, Preset>();
+for (const preset of presets) {
+	if (presetMap.has(preset.id)) {
+		throw new Error(`Duplicate preset ID: "${preset.id}"`);
+	}
+	presetMap.set(preset.id, preset);
+}
+
+export const presetRegistry: ReadonlyMap<string, Preset> = presetMap;
+
+export function getPresetById(id: string): Preset | undefined {
+	return presetMap.get(id);
+}
+
+export function getAllPresets(): Preset[] {
+	return [...presets];
+}

package/src/resolver.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, it } from "vitest";
+import { resolve } from "./resolver.js";
+
+describe("resolve", () => {
+	it("returns empty services for empty input", () => {
+		const result = resolve({ services: [], skillPacks: [] });
+		expect(result.services).toHaveLength(0);
+		expect(result.isValid).toBe(true);
+		expect(result.estimatedMemoryMB).toBe(512); // base OpenClaw only
+	});
+
+	it("resolves a single service with no dependencies", () => {
+		const result = resolve({ services: ["redis"], skillPacks: [] });
+		expect(result.services).toHaveLength(1);
+		expect(result.services[0]!.definition.id).toBe("redis");
+		expect(result.isValid).toBe(true);
+	});
+
+	it("auto-adds PostgreSQL when n8n is selected", () => {
+		const result = resolve({ services: ["n8n"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("n8n");
+		expect(ids).toContain("postgresql");
+		expect(result.addedDependencies).toContainEqual(
+			expect.objectContaining({ service: "postgresql" }),
+		);
+		expect(result.isValid).toBe(true);
+	});
+
+	it("auto-adds Prometheus when Grafana is selected", () => {
+		const result = resolve({ services: ["grafana"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("grafana");
+		expect(ids).toContain("prometheus");
+	});
+
+	it("detects Redis + Valkey conflict", () => {
+		const result = resolve({ services: ["redis", "valkey"], skillPacks: [] });
+		expect(result.isValid).toBe(false);
+		expect(result.errors).toContainEqual(expect.objectContaining({ type: "conflict" }));
+	});
+
+	it("detects Caddy + Traefik conflict", () => {
+		const result = resolve({ services: ["caddy", "traefik"], skillPacks: [] });
+		expect(result.isValid).toBe(false);
+		expect(result.errors).toContainEqual(expect.objectContaining({ type: "conflict" }));
+	});
+
+	it("expands research-agent skill pack", () => {
+		const result = resolve({ services: [], skillPacks: ["research-agent"] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("qdrant");
+		expect(ids).toContain("searxng");
+		expect(ids).toContain("browserless");
+		expect(result.isValid).toBe(true);
+	});
+
+	it("expands video-creator skill pack", () => {
+		const result = resolve({ services: [], skillPacks: ["video-creator"] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("ffmpeg");
+		expect(ids).toContain("remotion");
+		expect(ids).toContain("minio");
+	});
+
+	it("expands dev-ops skill pack with transitive deps", () => {
+		const result = resolve({ services: [], skillPacks: ["dev-ops"] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("n8n");
+		expect(ids).toContain("redis");
+		expect(ids).toContain("uptime-kuma");
+		expect(ids).toContain("grafana");
+		expect(ids).toContain("prometheus");
+		// n8n requires postgresql (transitive)
+		expect(ids).toContain("postgresql");
+	});
+
+	it("reports unknown service IDs", () => {
+		const result = resolve({ services: ["nonexistent"], skillPacks: [] });
+		expect(result.errors).toContainEqual(expect.objectContaining({ type: "unknown_service" }));
+	});
+
+	it("reports unknown skill pack IDs", () => {
+		const result = resolve({ services: [], skillPacks: ["nonexistent-pack"] });
+		expect(result.errors).toContainEqual(expect.objectContaining({ type: "unknown_skill_pack" }));
+	});
+
+	it("does not duplicate services already selected by user", () => {
+		const result = resolve({
+			services: ["qdrant", "searxng", "browserless"],
+			skillPacks: ["research-agent"],
+		});
+		const ids = result.services.map((s) => s.definition.id);
+		const qdrantCount = ids.filter((id) => id === "qdrant").length;
+		expect(qdrantCount).toBe(1);
+	});
+
+	it("estimates memory correctly", () => {
+		const result = resolve({ services: ["redis"], skillPacks: [] });
+		// 512 (base) + 128 (redis) = 640
+		expect(result.estimatedMemoryMB).toBe(640);
+	});
+
+	it("adds proxy service when specified", () => {
+		const result = resolve({ services: ["redis"], skillPacks: [], proxy: "caddy" });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("caddy");
+	});
+
+	it("adds monitoring stack when flag is set", () => {
+		const result = resolve({ services: [], skillPacks: [], monitoring: true });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("uptime-kuma");
+		expect(ids).toContain("grafana");
+		expect(ids).toContain("prometheus");
+	});
+
+	it("is deterministic - same input gives same output", () => {
+		const input = { services: ["redis", "qdrant", "n8n"], skillPacks: ["research-agent"] };
+		const result1 = resolve(input);
+		const result2 = resolve(input);
+		const ids1 = result1.services.map((s) => s.definition.id);
+		const ids2 = result2.services.map((s) => s.definition.id);
+		expect(ids1).toEqual(ids2);
+	});
+
+	it("topologically sorts dependencies before dependents", () => {
+		const result = resolve({ services: ["n8n"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		const pgIndex = ids.indexOf("postgresql");
+		const n8nIndex = ids.indexOf("n8n");
+		expect(pgIndex).toBeLessThan(n8nIndex);
+	});
+
+	it("warns about GPU when AI services selected without gpu flag", () => {
+		// Ollama doesn't have gpuRequired=true (it's recommended not required)
+		// but we should still check GPU warning logic works
+		const result = resolve({ services: ["redis"], skillPacks: [], gpu: false });
+		// Redis doesn't need GPU, so no GPU warnings
+		const gpuWarnings = result.warnings.filter((w) => w.type === "gpu");
+		expect(gpuWarnings).toHaveLength(0);
+	});
+
+	it("resolves tailscale as single service with no dependencies", () => {
+		const result = resolve({ services: ["tailscale"], skillPacks: [] });
+		expect(result.services).toHaveLength(1);
+		expect(result.services[0]!.definition.id).toBe("tailscale");
+		expect(result.isValid).toBe(true);
+	});
+
+	it("resolves coolify and dokploy as single services", () => {
+		const result = resolve({ services: ["coolify", "dokploy"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("coolify");
+		expect(ids).toContain("dokploy");
+		expect(result.isValid).toBe(true);
+	});
+
+	it("auto-adds postgresql, redis, and livekit when lasuite-meet-backend is selected", () => {
+		const result = resolve({ services: ["lasuite-meet-backend"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("lasuite-meet-backend");
+		expect(ids).toContain("postgresql");
+		expect(ids).toContain("redis");
+		expect(ids).toContain("livekit");
+		expect(result.addedDependencies.some((a) => a.service === "postgresql")).toBe(true);
+		expect(result.isValid).toBe(true);
+	});
+
+	it("resolves La Suite Meet preset (postgresql, redis, livekit, backend, frontend, agents)", () => {
+		const lasuiteMeetServices = [
+			"postgresql",
+			"redis",
+			"livekit",
+			"lasuite-meet-backend",
+			"lasuite-meet-frontend",
+			"lasuite-meet-agents",
+		];
+		const result = resolve({ services: lasuiteMeetServices, skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		for (const id of lasuiteMeetServices) {
+			expect(ids).toContain(id);
+		}
+		expect(result.isValid).toBe(true);
+	});
+
+	it("orders lasuite-meet-backend after postgresql, redis, and livekit", () => {
+		const result = resolve({
+			services: ["lasuite-meet-backend", "lasuite-meet-frontend"],
+			skillPacks: [],
+		});
+		const ids = result.services.map((s) => s.definition.id);
+		const pgIdx = ids.indexOf("postgresql");
+		const redisIdx = ids.indexOf("redis");
+		const livekitIdx = ids.indexOf("livekit");
+		const backendIdx = ids.indexOf("lasuite-meet-backend");
+		const frontendIdx = ids.indexOf("lasuite-meet-frontend");
+		expect(pgIdx).toBeGreaterThanOrEqual(0);
+		expect(backendIdx).toBeGreaterThan(pgIdx);
+		expect(backendIdx).toBeGreaterThan(redisIdx);
+		expect(backendIdx).toBeGreaterThan(livekitIdx);
+		expect(frontendIdx).toBeGreaterThan(backendIdx);
+	});
+});