@better-openclaw/core 1.0.26 → 1.0.31

package/src/generators/env.ts

@@ -1,4 +1,6 @@
 import { randomBytes } from "node:crypto";
+import { getFrameworkById } from "../frameworks/index.js";
+import type { AgentFrameworkId } from "../frameworks/types.js";
 import type { ResolverOutput } from "../types.js";
 import { getDbRequirements } from "./postgres-init.js";
 
@@ -17,6 +19,8 @@ export interface EnvGeneratorOptions {
 	composeProfiles?: string[];
 	/** OpenClaw image variant (official, coolify, alpine). */
 	openclawImage?: "official" | "coolify" | "alpine";
+	/** Primary agent framework (defaults to "openclaw"). */
+	primaryFramework?: AgentFrameworkId;
 }
 
 /**
@@ -69,191 +73,37 @@ export function generateEnvFiles(
 		});
 	}
 
-	// ── Base OpenClaw Variables ──────────────────────────────────────────────
+	// ── Framework-Specific Base Variables ────────────────────────────────────
 
-	lines.push({
-		comment: formatComment("OpenClaw version to deploy", "OpenClaw Core", true, false),
-		key: "OPENCLAW_VERSION",
-		exampleValue: version,
-		actualValue: version,
-	});
-
-	const gatewayToken = options.generateSecrets ? randomBytes(24).toString("hex") : "";
-
-	lines.push({
-		comment: formatComment(
-			"Authentication token for the OpenClaw gateway API",
-			"OpenClaw Core",
-			true,
-			true,
-		),
-		key: "OPENCLAW_GATEWAY_TOKEN",
-		exampleValue: "your_gateway_token_here",
-		actualValue: gatewayToken,
-	});
-
-	lines.push({
-		comment: formatComment("Port the OpenClaw gateway listens on", "OpenClaw Core", true, false),
-		key: "OPENCLAW_GATEWAY_PORT",
-		exampleValue: "18789",
-		actualValue: "18789",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Port for the OpenClaw ACP bridge (WebSocket)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_BRIDGE_PORT",
-		exampleValue: "18790",
-		actualValue: "18790",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Gateway network bind mode: 'lan' (all interfaces, required for Docker). Use 'loopback' only for native (non-Docker) installs with Tailscale serve/funnel",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_GATEWAY_BIND",
-		exampleValue: "lan",
-		actualValue: "lan",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Host path to OpenClaw configuration directory",
-			"OpenClaw Core",
-			true,
-			false,
-		),
-		key: "OPENCLAW_CONFIG_DIR",
-		exampleValue: "./openclaw/config",
-		actualValue: "./openclaw/config",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Host path to OpenClaw workspace directory",
-			"OpenClaw Core",
-			true,
-			false,
-		),
-		key: "OPENCLAW_WORKSPACE_DIR",
-		exampleValue: "./openclaw/workspace",
-		actualValue: "./openclaw/workspace",
-	});
-
-	// Set OPENCLAW_IMAGE based on variant (empty = use compose default)
-	const imageVariantMap: Record<string, string> = {
-		official: "", // use compose default (ghcr.io/openclaw/openclaw:VERSION)
-		coolify: "coollabsio/openclaw:latest",
-		alpine: "alpine/openclaw:latest",
-	};
-	const imageValue = imageVariantMap[options.openclawImage ?? "official"] ?? "";
-
-	lines.push({
-		comment: formatComment(
-			`OpenClaw Docker image variant: ${options.openclawImage ?? "official"} (official, coolify, alpine)`,
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_IMAGE",
-		exampleValue: "",
-		actualValue: imageValue,
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Extra bind mounts for gateway and CLI containers (comma-separated, format: source:target[:options])",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_EXTRA_MOUNTS",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Named volume or host path for /home/node persistence across container restarts",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_HOME_VOLUME",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Extra apt packages to install during Docker image build (space-separated)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_DOCKER_APT_PACKAGES",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Alternative auth: gateway password (use token OR password, not both)",
-			"OpenClaw Core",
-			false,
-			true,
-		),
-		key: "OPENCLAW_GATEWAY_PASSWORD",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Override state directory path (default: ~/.openclaw)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_STATE_DIR",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Override config file path (default: ~/.openclaw/openclaw.json)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_CONFIG_PATH",
-		exampleValue: "",
-		actualValue: "",
-	});
+	const framework = getFrameworkById(options.primaryFramework ?? "openclaw");
+	if (framework) {
+		const sectionName = framework.getEnvSectionName();
+		const fwEnvVars = framework.getBaseEnvVars({
+			generateSecrets: options.generateSecrets,
+			domain: options.domain,
+			frameworkVersion: version,
+			frameworkImageVariant: options.openclawImage ?? "official",
+		});
 
-	lines.push({
-		comment: formatComment(
-			"Import missing keys from login shell profile (set to 1 to enable)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_LOAD_SHELL_ENV",
-		exampleValue: "",
-		actualValue: "",
-	});
+		for (const envLine of fwEnvVars) {
+			lines.push({
+				comment: formatComment(
+					envLine.comment,
+					sectionName,
+					false,
+					envLine.key.includes("TOKEN") || envLine.key.includes("PASSWORD"),
+				),
+				key: envLine.key,
+				exampleValue: envLine.exampleValue,
+				actualValue: envLine.actualValue,
+			});
+		}
+	}
 
 	if (options.domain) {
+		const sectionName = framework?.getEnvSectionName() ?? "Core";
 		lines.push({
-			comment: formatComment("Primary domain for service routing", "OpenClaw Core", false, false),
+			comment: formatComment("Primary domain for service routing", sectionName, false, false),
 			key: "OPENCLAW_DOMAIN",
 			exampleValue: "example.com",
 			actualValue: options.domain,

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/health-check.ts

@@ -101,7 +101,7 @@ function generateBashScript(resolved: ResolverOutput, options: HealthCheckOption
 	}
 
 	// Build the log-scan service list
-	const svcIdList = checks.map((s) => '"' + s.id + '"').join(" ");
+	const svcIdList = checks.map((s) => `"${s.id}"`).join(" ");
 
 	const lines: string[] = [
 		"#!/usr/bin/env bash",
@@ -450,7 +450,7 @@ function generateBashScript(resolved: ResolverOutput, options: HealthCheckOption
 		"fi",
 	];
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }
 
 // ─── PowerShell Script ──────────────────────────────────────────────────────
@@ -522,7 +522,7 @@ function generatePowerShellScript(resolved: ResolverOutput, options: HealthCheck
 		bmChecks.push("");
 	}
 
-	const svcIdList = checks.map((s) => '"' + s.id + '"').join(", ");
+	const svcIdList = checks.map((s) => `"${s.id}"`).join(", ");
 
 	const lines: string[] = [
 		"#Requires -Version 5.1",
@@ -808,5 +808,5 @@ function generatePowerShellScript(resolved: ResolverOutput, options: HealthCheck
 		"}",
 	];
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }

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/openclaw-json.ts

@@ -351,6 +351,61 @@ const LOCAL_PROVIDER_PORTS: Record<string, number> = {
  * Generates a default `openclaw/config/openclaw.json` tailored
  * to the services installed in the stack.
  */
+/**
+ * Builds the memory configuration based on installed services.
+ * Priority: mem0 > memu > hindsight > builtin.
+ * Also detects vector databases and adds vectorStore config.
+ */
+function buildMemoryConfig(resolved: ResolverOutput): Record<string, unknown> {
+	const has = (id: string) => resolved.services.some((s) => s.definition.id === id);
+
+	// Detect vector databases (priority order)
+	const vectorStore = has("qdrant")
+		? { provider: "qdrant", host: "qdrant", port: 6333 }
+		: has("chromadb")
+			? { provider: "chromadb", host: "chromadb", port: 8000 }
+			: has("weaviate")
+				? { provider: "weaviate", host: "weaviate", port: 8080 }
+				: has("milvus")
+					? { provider: "milvus", uri: "http://milvus:19530" }
+					: null;
+
+	// Detect memory services (priority order)
+	if (has("mem0")) {
+		return {
+			backend: "mem0",
+			citations: "auto",
+			mem0: { host: "mem0", port: 8000, userId: "openclaw-agent" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	if (has("memu")) {
+		return {
+			backend: "memu",
+			citations: "auto",
+			memu: { host: "memu", port: 8000, agentId: "openclaw-agent" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	if (has("hindsight")) {
+		return {
+			backend: "hindsight",
+			citations: "auto",
+			hindsight: { host: "hindsight", port: 8888, namespace: "openclaw" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	// No memory service — use builtin, optionally with a vector store
+	return {
+		backend: "builtin",
+		citations: "auto",
+		...(vectorStore ? { vectorStore } : {}),
+	};
+}
+
 export function generateOpenClawConfig(
 	resolved: ResolverOutput,
 	options: OpenClawConfigOptions,
@@ -667,11 +722,8 @@ export function generateOpenClawConfig(
 				maxPingPongTurns: 5,
 			},
 		},
-		// Memory — vector search over session history and markdown notes
-		memory: {
-			backend: "builtin",
-			citations: "auto",
-		},
+		// Memory — dynamically configured based on installed services
+		memory: buildMemoryConfig(resolved),
 		// UI customization
 		ui: {
 			assistant: {