@better-openclaw/core 1.0.8 → 1.0.10

package/src/skills/registry.ts

@@ -35,7 +35,13 @@ const skillPacks: SkillPack[] = [
 		name: "DevOps",
 		description: "Monitor services, automate workflows, and manage infrastructure alerts",
 		requiredServices: ["n8n", "redis", "uptime-kuma", "grafana", "prometheus"],
-		skills: ["n8n-trigger", "redis-cache"],
+		skills: [
+			"n8n-trigger",
+			"redis-cache",
+			"grafana-dashboard",
+			"prometheus-query",
+			"uptime-kuma-monitor",
+		],
 		icon: "⚙️",
 		tags: ["devops", "monitoring", "automation"],
 	},
@@ -45,7 +51,7 @@ const skillPacks: SkillPack[] = [
 		description:
 			"Index documents with vector search and full-text search for comprehensive retrieval",
 		requiredServices: ["qdrant", "postgresql", "meilisearch"],
-		skills: ["qdrant-memory"],
+		skills: ["qdrant-memory", "postgresql-query", "meilisearch-index"],
 		icon: "📚",
 		tags: ["knowledge", "search", "indexing"],
 	},
@@ -64,7 +70,12 @@ const skillPacks: SkillPack[] = [
 		description:
 			"Full social media content pipeline with scheduling, media processing, analytics, and storage",
 		requiredServices: ["postiz", "ffmpeg", "minio", "redis", "postgresql"],
-		skills: ["ffmpeg-process", "minio-storage", "redis-cache"],
+		skills: [
+			"ffmpeg-process",
+			"minio-storage",
+			"redis-cache",
+			"postiz-schedule",
+		],
 		icon: "📱",
 		tags: ["social-media", "content", "scheduling", "analytics"],
 	},
@@ -74,7 +85,7 @@ const skillPacks: SkillPack[] = [
 		description:
 			"Full AI experimentation stack with chat UIs, LLM gateway, local models, and document chat",
 		requiredServices: ["ollama", "open-webui", "litellm"],
-		skills: ["ollama-local-llm"],
+		skills: ["ollama-local-llm", "open-webui-chat", "litellm-gateway"],
 		icon: "🧪",
 		tags: ["ai", "llm", "playground", "experimentation"],
 	},
@@ -84,7 +95,7 @@ const skillPacks: SkillPack[] = [
 		description:
 			"AI-powered development environment with coding agents, Git hosting, and browser IDE",
 		requiredServices: ["claude-code", "gitea", "code-server"],
-		skills: [],
+		skills: ["claude-code-assist", "gitea-repo", "code-server-develop"],
 		icon: "💻",
 		tags: ["coding", "development", "ide", "git"],
 	},
@@ -94,12 +105,347 @@ const skillPacks: SkillPack[] = [
 		description:
 			"Enterprise knowledge management with wiki, document processing, analytics, and vector search",
 		requiredServices: ["outline", "paperless-ngx", "qdrant", "postgresql", "redis"],
-		skills: ["qdrant-memory"],
+		skills: [
+			"qdrant-memory",
+			"outline-wiki",
+			"paperless-archive",
+			"postgresql-query",
+			"redis-cache",
+		],
 		icon: "📚",
 		tags: ["knowledge", "wiki", "documents", "search"],
 	},
+	// ── New Skill Packs ───────────────────────────────────────────────
+	{
+		id: "data-engineer",
+		name: "Data Engineer",
+		description:
+			"Process and transform data with PostgreSQL, CSV/JSON/XML transforms, and PDF extraction",
+		requiredServices: ["postgresql"],
+		skills: [
+			"postgresql-query",
+			"csv-transform",
+			"json-transform",
+			"xml-parse",
+			"pdf-extract",
+			"excel-process",
+			"markdown-convert",
+		],
+		icon: "🔧",
+		tags: ["data", "etl", "transform", "processing"],
+	},
+	{
+		id: "nlp-pipeline",
+		name: "NLP Pipeline",
+		description:
+			"Natural language processing with summarization, translation, classification, and embeddings via Ollama",
+		requiredServices: ["ollama"],
+		skills: [
+			"text-summarize",
+			"text-translate",
+			"text-classify",
+			"text-embed",
+			"ollama-local-llm",
+		],
+		icon: "🧠",
+		tags: ["nlp", "text", "embeddings", "translation"],
+	},
+	{
+		id: "image-processor",
+		name: "Image Processor",
+		description:
+			"Resize, convert, and OCR images with ImageMagick and Tesseract",
+		requiredServices: ["ffmpeg"],
+		skills: [
+			"image-resize",
+			"image-convert",
+			"image-ocr",
+			"ffmpeg-process",
+		],
+		icon: "🖼️",
+		tags: ["image", "ocr", "media", "conversion"],
+	},
+	{
+		id: "api-integrator",
+		name: "API Integrator",
+		description:
+			"HTTP requests, webhooks, and GraphQL queries for external API integration",
+		requiredServices: [],
+		skills: [
+			"http-request",
+			"api-webhook",
+			"graphql-query",
+		],
+		icon: "🌐",
+		tags: ["api", "http", "webhook", "graphql"],
+	},
+	{
+		id: "security-ops",
+		name: "Security Ops",
+		description:
+			"JWT validation, hashing, SSL checks, port scanning, and network diagnostics",
+		requiredServices: [],
+		skills: [
+			"jwt-manage",
+			"hash-generate",
+			"ssl-check",
+			"dns-lookup",
+			"port-scan",
+			"ping-check",
+		],
+		icon: "🛡️",
+		tags: ["security", "networking", "diagnostics"],
+	},
+	{
+		id: "communication-hub",
+		name: "Communication Hub",
+		description:
+			"Multi-channel messaging with Matrix, Mattermost, Rocket.Chat, email, and push notifications",
+		requiredServices: ["matrix-synapse", "gotify"],
+		skills: [
+			"matrix-message",
+			"mattermost-post",
+			"rocketchat-send",
+			"gotify-notify",
+			"ntfy-publish",
+			"email-send",
+		],
+		icon: "📨",
+		tags: ["messaging", "notifications", "email", "chat"],
+	},
+	{
+		id: "analytics-suite",
+		name: "Analytics Suite",
+		description:
+			"Web and product analytics with Matomo, Umami, OpenPanel, Grafana, and Prometheus",
+		requiredServices: ["grafana", "prometheus"],
+		skills: [
+			"matomo-track",
+			"umami-analytics",
+			"openpanel-analyze",
+			"grafana-dashboard",
+			"prometheus-query",
+		],
+		icon: "📊",
+		tags: ["analytics", "monitoring", "metrics", "dashboards"],
+	},
+	{
+		id: "full-devops",
+		name: "Full DevOps",
+		description:
+			"Complete DevOps toolkit with Git hosting, container management, deployments, monitoring, and log viewing",
+		requiredServices: ["gitea", "portainer", "coolify", "grafana", "prometheus"],
+		skills: [
+			"gitea-repo",
+			"portainer-manage",
+			"coolify-deploy",
+			"dokploy-deploy",
+			"watchtower-update",
+			"dozzle-logs",
+			"grafana-dashboard",
+			"prometheus-query",
+			"uptime-kuma-monitor",
+			"beszel-monitor",
+		],
+		icon: "🏗️",
+		tags: ["devops", "ci-cd", "containers", "deployment"],
+	},
+	{
+		id: "document-manager",
+		name: "Document Manager",
+		description:
+			"Document processing pipeline with wiki, archival, OCR, Q&A, and PDF extraction",
+		requiredServices: ["outline", "paperless-ngx"],
+		skills: [
+			"outline-wiki",
+			"paperless-archive",
+			"docsgpt-ask",
+			"pdf-extract",
+			"image-ocr",
+		],
+		icon: "📑",
+		tags: ["documents", "wiki", "ocr", "archive"],
+	},
+	{
+		id: "ai-coding-team",
+		name: "AI Coding Team",
+		description:
+			"Multi-agent AI coding ensemble with Claude Code, Codex, Gemini CLI, OpenCode, and browser IDE",
+		requiredServices: ["code-server", "gitea"],
+		skills: [
+			"claude-code-assist",
+			"codex-generate",
+			"gemini-cli-query",
+			"opencode-develop",
+			"code-server-develop",
+			"gitea-repo",
+		],
+		icon: "🤖",
+		tags: ["ai-coding", "agents", "development", "ide"],
+	},
+	// ── Internet-Verified Skill Packs ────────────────────────────────
+	{
+		id: "rag-pipeline",
+		name: "RAG Pipeline",
+		description:
+			"Build retrieval-augmented generation systems with LangChain, LlamaIndex, Haystack, and vector databases",
+		requiredServices: ["milvus"],
+		skills: [
+			"langchain-agent",
+			"llamaindex-query",
+			"haystack-rag",
+			"ragflow-pipeline",
+			"milvus-vectors",
+			"firecrawl-scrape",
+		],
+		icon: "🧠",
+		tags: ["rag", "ai", "embeddings", "search", "llm"],
+	},
+	{
+		id: "self-hosted-cloud",
+		name: "Self-Hosted Cloud",
+		description:
+			"Complete self-hosted infrastructure with cloud storage, photos, media streaming, and password management",
+		requiredServices: ["nextcloud", "immich", "jellyfin", "vaultwarden"],
+		skills: [
+			"nextcloud-files",
+			"immich-photos",
+			"jellyfin-media",
+			"vaultwarden-manage",
+		],
+		icon: "☁️",
+		tags: ["self-hosted", "cloud", "storage", "media", "security"],
+	},
+	{
+		id: "ai-agent-orchestra",
+		name: "AI Agent Orchestra",
+		description:
+			"Multi-agent AI orchestration with CrewAI, AutoGPT, LangChain, Langflow, and Open Interpreter",
+		requiredServices: [],
+		skills: [
+			"crewai-orchestrate",
+			"autogpt-autonomous",
+			"langchain-agent",
+			"langflow-build",
+			"open-interpreter-run",
+		],
+		icon: "🎭",
+		tags: ["ai", "agents", "multi-agent", "orchestration", "autonomous"],
+	},
+	{
+		id: "cicd-pipeline",
+		name: "CI/CD Pipeline",
+		description:
+			"Full CI/CD pipeline with Jenkins, ArgoCD, Woodpecker, and infrastructure as code",
+		requiredServices: ["jenkins"],
+		skills: [
+			"jenkins-pipeline",
+			"argocd-deploy",
+			"woodpecker-ci",
+			"terraform-provision",
+			"ansible-configure",
+		],
+		icon: "🔄",
+		tags: ["ci-cd", "devops", "gitops", "infrastructure"],
+	},
+	{
+		id: "zero-trust-security",
+		name: "Zero-Trust Security",
+		description:
+			"Enterprise security with SSO, secrets management, VPN, intrusion detection, and feature flags",
+		requiredServices: ["authentik", "crowdsec"],
+		skills: [
+			"authentik-auth",
+			"keycloak-auth",
+			"vault-secrets",
+			"infisical-secrets",
+			"netbird-vpn",
+			"teleport-access",
+			"crowdsec-protect",
+		],
+		icon: "🔒",
+		tags: ["security", "zero-trust", "sso", "secrets", "vpn"],
+	},
+	{
+		id: "content-platform",
+		name: "Content Platform",
+		description:
+			"Publishing and CMS platform with Ghost, Strapi, Directus, and newsletter management",
+		requiredServices: ["ghost"],
+		skills: [
+			"ghost-publish",
+			"strapi-cms",
+			"directus-cms",
+			"listmonk-email",
+			"plausible-analytics",
+		],
+		icon: "📝",
+		tags: ["cms", "publishing", "blog", "newsletter", "analytics"],
+	},
+	{
+		id: "backend-platform",
+		name: "Backend Platform",
+		description:
+			"Backend-as-a-service with Supabase, Appwrite, PocketBase, and API gateway",
+		requiredServices: ["supabase"],
+		skills: [
+			"supabase-query",
+			"appwrite-backend",
+			"pocketbase-backend",
+			"kong-gateway",
+			"rabbitmq-queue",
+		],
+		icon: "⚡",
+		tags: ["backend", "baas", "api", "database", "messaging"],
+	},
+	{
+		id: "observability-stack",
+		name: "Observability Stack",
+		description:
+			"Full observability with Loki logs, SigNoz APM, Sentry errors, Gatus health, and Elasticsearch",
+		requiredServices: ["loki", "signoz"],
+		skills: [
+			"loki-logs",
+			"signoz-observe",
+			"sentry-errors",
+			"gatus-health",
+			"elasticsearch-search",
+		],
+		icon: "📡",
+		tags: ["observability", "logs", "apm", "errors", "health"],
+	},
+	{
+		id: "document-hub",
+		name: "Document Hub",
+		description:
+			"Document management with Paperless-ngx, BookStack wiki, Stirling PDF tools, and Excalidraw",
+		requiredServices: ["paperless-ngx"],
+		skills: [
+			"paperless-ngx-docs",
+			"bookstack-wiki",
+			"stirling-pdf-tools",
+			"excalidraw-draw",
+		],
+		icon: "📑",
+		tags: ["documents", "wiki", "pdf", "collaboration"],
+	},
+	{
+		id: "smart-home",
+		name: "Smart Home",
+		description:
+			"Home automation and event-driven workflows with Home Assistant, Huginn, and Activepieces",
+		requiredServices: ["homeassistant"],
+		skills: [
+			"home-assistant-automate",
+			"huginn-automate",
+			"activepieces-flow",
+		],
+		icon: "🏠",
+		tags: ["iot", "automation", "smart-home", "workflows"],
+	},
 ];
 
+
 const packMap = new Map<string, SkillPack>();
 for (const pack of skillPacks) {
 	if (packMap.has(pack.id)) {

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