@better-openclaw/core 1.0.26 → 1.0.31

package/src/frameworks/zeroclaw.ts

@@ -0,0 +1,148 @@
+import type { ResolverOutput } from "../types.js";
+import type {
+	AgentFrameworkDefinition,
+	EnvLine,
+	FrameworkComposeOptions,
+	FrameworkConfigOptions,
+	FrameworkConfigResult,
+	FrameworkEnvOptions,
+	GatewayBuildResult,
+} from "./types.js";
+
+const IMAGE_VARIANTS: Record<string, string> = {
+	official: "ghcr.io/zeroclaw-labs/zeroclaw",
+};
+
+function getZeroclawImage(_variant: string, version: string): string {
+	const base = IMAGE_VARIANTS.official;
+	const tag = version !== "latest" ? version : "latest";
+	return `${base}:${tag}`;
+}
+
+const PROVIDER_ENV_KEYS = ["API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "OPENROUTER_API_KEY"];
+
+export const zeroclawFramework: AgentFrameworkDefinition = {
+	id: "zeroclaw",
+	name: "ZeroClaw",
+	icon: "⚡",
+	description: "Rust-based 3.4MB agent binary with <10ms cold start",
+	runtime: "rust",
+	canBePrimary: true,
+	canBeCompanion: true,
+	networkName: "zeroclaw-network",
+	imageVariants: IMAGE_VARIANTS,
+	defaultImageVariant: "official",
+
+	buildGatewayService(
+		resolved: ResolverOutput,
+		options: FrameworkComposeOptions,
+		dependsOn?: Record<string, { condition: string }>,
+	): GatewayBuildResult {
+		const allVolumes = new Set<string>();
+		const defaultImage = getZeroclawImage(
+			options.frameworkImageVariant ?? "official",
+			options.frameworkVersion,
+		);
+
+		const gatewayEnv: Record<string, string> = {
+			API_KEY: "${API_KEY}",
+			PROVIDER: "${ZEROCLAW_PROVIDER:-openrouter}",
+			ZEROCLAW_GATEWAY_PORT: "${ZEROCLAW_GATEWAY_PORT:-42617}",
+			ZEROCLAW_ALLOW_PUBLIC_BIND: "true",
+		};
+
+		// Collect env vars from companion services
+		for (const { definition: def } of resolved.services) {
+			for (const env of def.openclawEnvVars) {
+				gatewayEnv[env.key] = env.secret ? `\${${env.key}}` : env.defaultValue;
+			}
+		}
+
+		const gateway: Record<string, unknown> = {
+			image: `\${ZEROCLAW_IMAGE:-${defaultImage}}`,
+			environment: gatewayEnv,
+			volumes: ["${ZEROCLAW_DATA_DIR:-./zeroclaw/data}:/zeroclaw-data"],
+			ports: ["${ZEROCLAW_HOST_PORT:-3000}:${ZEROCLAW_GATEWAY_PORT:-42617}"],
+			networks: [this.networkName],
+			restart: "unless-stopped",
+			deploy: {
+				resources: {
+					limits: { cpus: "2", memory: "2G" },
+					reservations: { cpus: "0.5", memory: "512M" },
+				},
+			},
+			healthcheck: {
+				test: ["CMD", "zeroclaw", "status"],
+				interval: "60s",
+				timeout: "10s",
+				retries: 3,
+				start_period: "10s",
+			},
+		};
+
+		if (dependsOn && Object.keys(dependsOn).length > 0) {
+			gateway.depends_on = dependsOn;
+		}
+
+		return { gatewayService: gateway, cliService: null, allVolumes };
+	},
+
+	generateConfig(
+		_resolved: ResolverOutput,
+		_options: FrameworkConfigOptions,
+	): FrameworkConfigResult | null {
+		// ZeroClaw uses config.toml; generated on first run or via env vars
+		return null;
+	},
+
+	getBaseEnvVars(_options: FrameworkEnvOptions): EnvLine[] {
+		return [
+			{
+				comment: "ZeroClaw Docker image override",
+				key: "ZEROCLAW_IMAGE",
+				exampleValue: "",
+				actualValue: "",
+			},
+			{
+				comment: "LLM provider name (openrouter, anthropic, openai, etc.)",
+				key: "ZEROCLAW_PROVIDER",
+				exampleValue: "openrouter",
+				actualValue: "openrouter",
+			},
+			{
+				comment: "Internal gateway port inside container",
+				key: "ZEROCLAW_GATEWAY_PORT",
+				exampleValue: "42617",
+				actualValue: "42617",
+			},
+			{
+				comment: "Host-facing port for ZeroClaw gateway",
+				key: "ZEROCLAW_HOST_PORT",
+				exampleValue: "3000",
+				actualValue: "3000",
+			},
+			{
+				comment: "Host path to ZeroClaw data directory",
+				key: "ZEROCLAW_DATA_DIR",
+				exampleValue: "./zeroclaw/data",
+				actualValue: "./zeroclaw/data",
+			},
+		];
+	},
+
+	getMandatoryServices(): string[] {
+		return [];
+	},
+
+	getRecommendedServices(): string[] {
+		return [];
+	},
+
+	getProviderEnvKeys(): string[] {
+		return [...PROVIDER_ENV_KEYS];
+	},
+
+	getEnvSectionName(): string {
+		return "ZeroClaw Core";
+	},
+};

package/src/generate.test.ts

@@ -128,7 +128,7 @@ describe("generate (end-to-end)", () => {
 		});
 
 		expect(result.files).toHaveProperty("caddy/Caddyfile");
-		expect(result.files["caddy/Caddyfile"]!.length).toBeGreaterThan(0);
+		expect(result.files["caddy/Caddyfile"]?.length).toBeGreaterThan(0);
 	});
 
 	it("generates prometheus config when monitoring enabled", () => {
@@ -303,10 +303,61 @@ describe("generate (end-to-end)", () => {
 
 		for (const script of expectedScripts) {
 			expect(result.files).toHaveProperty(script);
-			expect(result.files[script]!.length).toBeGreaterThan(0);
+			expect(result.files[script]?.length).toBeGreaterThan(0);
 		}
 	});
 
+	it("generates a stack with zeroclaw as primary framework", () => {
+		const result = generate({
+			projectName: "zeroclaw-stack",
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			deployment: "local",
+			generateSecrets: true,
+			openclawVersion: "latest",
+			primaryFramework: "zeroclaw",
+		});
+
+		const composed = parse(result.files["docker-compose.yml"]!);
+
+		// Should have zeroclaw-gateway, not openclaw-gateway
+		expect(composed.services).toHaveProperty("zeroclaw-gateway");
+		expect(composed.services).not.toHaveProperty("openclaw-gateway");
+
+		// Should NOT have convex/mission-control/tailscale
+		expect(composed.services).not.toHaveProperty("convex");
+		expect(composed.services).not.toHaveProperty("mission-control");
+		expect(composed.services).not.toHaveProperty("tailscale");
+
+		// Network should be zeroclaw-network
+		expect(composed.networks).toHaveProperty("zeroclaw-network");
+	});
+
+	it("generates a stack with companion frameworks", () => {
+		const result = generate({
+			projectName: "multi-fw-stack",
+			services: ["redis"],
+			skillPacks: [],
+			proxy: "none",
+			gpu: false,
+			platform: "linux/amd64",
+			deployment: "local",
+			generateSecrets: true,
+			openclawVersion: "latest",
+			companionFrameworks: ["claude-code"],
+		});
+
+		const composed = parse(result.files["docker-compose.yml"]!);
+
+		// Primary OpenClaw gateway should be present
+		expect(composed.services).toHaveProperty("openclaw-gateway");
+		// Companion Claude Code should be present
+		expect(composed.services).toHaveProperty("claude-code-companion");
+	});
+
 	it("all generated .env.example vars have comments", () => {
 		const result = generate({
 			projectName: "env-comments-stack",
@@ -326,7 +377,7 @@ describe("generate (end-to-end)", () => {
 		// Walk through lines: every non-empty, non-comment KEY=VALUE line should
 		// have a preceding comment line (starting with #).
 		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]!.trim();
+			const line = lines[i]?.trim();
 			if (line === "" || line.startsWith("#")) continue;
 
 			// This line looks like KEY=VALUE
@@ -334,7 +385,7 @@ describe("generate (end-to-end)", () => {
 				// There must be a comment somewhere before it (look backwards for a # line)
 				let foundComment = false;
 				for (let j = i - 1; j >= 0; j--) {
-					const prev = lines[j]!.trim();
+					const prev = lines[j]?.trim();
 					if (prev === "") continue; // skip blank lines
 					if (prev.startsWith("#")) {
 						foundComment = true;

package/src/generate.ts

@@ -5,6 +5,7 @@ import {
 } from "./bare-metal-partition.js";
 import { composeMultiFile } from "./composer.js";
 import { StackConfigError, ValidationError } from "./errors.js";
+import { getFrameworkById } from "./frameworks/index.js";
 import { generateBareMetalInstall } from "./generators/bare-metal-install.js";
 import { generateCaddyfile } from "./generators/caddy.js";
 import { generateCloneScripts } from "./generators/clone-repos.js";
@@ -16,7 +17,6 @@ import { generateHealthCheck } from "./generators/health-check.js";
 import { generateN8nWorkflows } from "./generators/n8n-workflows.js";
 import { generateNativeInstallScripts } from "./generators/native-services.js";
 import { generateOpenclawInstallScript } from "./generators/openclaw-install-script.js";
-import { generateOpenClawConfig } from "./generators/openclaw-json.js";
 import { generatePostgresInit } from "./generators/postgres-init.js";
 import { generatePrometheusConfig } from "./generators/prometheus.js";
 import { generateReadme } from "./generators/readme.js";
@@ -24,6 +24,7 @@ import { generateScripts } from "./generators/scripts.js";
 import { generateSkillFiles } from "./generators/skills.js";
 import { generateStackManifest } from "./generators/stack-manifest.js";
 import { generateTraefikConfig } from "./generators/traefik.js";
+import type { OperationsLogger } from "./logger/logger.js";
 import { migrateConfig } from "./migrations.js";
 import { resolve } from "./resolver.js";
 import type {
@@ -45,30 +46,52 @@ function getComposePlatform(platform: Platform): "linux/amd64" | "linux/arm64" {
  * Main orchestration function: takes generation input, resolves dependencies,
  * generates all files, validates, and returns the complete file tree.
  */
-export function generate(rawInput: GenerationInput): GenerationResult {
+export function generate(
+	rawInput: GenerationInput,
+	options?: { logger?: OperationsLogger },
+): GenerationResult {
+	const logger = options?.logger;
+
 	// Apply config migrations if needed
 	const input = migrateConfig(rawInput as Record<string, unknown>) as GenerationInput;
 
 	const composePlatform = getComposePlatform(input.platform);
 
+	logger?.info("generation", "Starting stack generation", {
+		projectName: input.projectName,
+		services: input.services,
+		platform: input.platform,
+		proxy: input.proxy,
+		deploymentType: input.deploymentType,
+	});
+
 	// 1. Resolve dependencies
 	const resolverInput: ResolverInput = {
 		services: input.services,
 		skillPacks: input.skillPacks,
 		aiProviders: input.aiProviders,
+		primaryFramework: input.primaryFramework,
 		proxy: input.proxy,
 		gpu: input.gpu,
 		platform: composePlatform,
 		monitoring: input.monitoring,
 	};
+	logger?.debug("resolution", "Resolving dependencies");
 	const resolved = resolve(resolverInput);
 
 	if (!resolved.isValid) {
-		throw new StackConfigError(
-			`Invalid stack configuration: ${resolved.errors.map((e) => e.message).join("; ")}`,
-		);
+		const errMsg = `Invalid stack configuration: ${resolved.errors.map((e) => e.message).join("; ")}`;
+		logger?.error("resolution", errMsg);
+		throw new StackConfigError(errMsg);
 	}
 
+	logger?.info("resolution", `Resolved ${resolved.services.length} services`, {
+		serviceCount: resolved.services.length,
+		addedDeps: resolved.addedDependencies.length,
+		warnings: resolved.warnings.length,
+		estimatedMemoryMB: resolved.estimatedMemoryMB,
+	});
+
 	const isBareMetal = input.deploymentType === "bare-metal";
 	let resolvedForCompose = resolved;
 	let nativeIds = new Set<string>();
@@ -85,6 +108,8 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		}
 	}
 
+	logger?.debug("generation", "Generating Docker Compose YAML");
+
 	// 2. Generate Docker Compose YAML (multi-file)
 	// Compute Traefik labels before composing (labels get injected into docker-compose services)
 	let traefikOutput: ReturnType<typeof generateTraefikConfig> | undefined;
@@ -94,6 +119,8 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 
 	const composeOptions = {
 		projectName: input.projectName,
+		primaryFramework: input.primaryFramework,
+		companionFrameworks: input.companionFrameworks,
 		proxy: input.proxy,
 		proxyHttpPort: input.proxyHttpPort,
 		proxyHttpsPort: input.proxyHttpsPort,
@@ -110,6 +137,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		openclawInstallMethod: input.openclawInstallMethod ?? "docker",
 	};
 	const composeResult = composeMultiFile(resolvedForCompose, composeOptions);
+	logger?.info("generation", `Generated ${Object.keys(composeResult.files).length} compose files`);
 
 	// 3. Validate (using the base docker-compose.yml)
 	const validation = validate(resolvedForCompose, composeResult.files["docker-compose.yml"] ?? "", {
@@ -117,10 +145,11 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		generateSecrets: input.generateSecrets,
 	});
 	if (!validation.valid) {
-		throw new ValidationError(
-			`Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`,
-		);
+		const errMsg = `Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`;
+		logger?.error("validation", errMsg);
+		throw new ValidationError(errMsg);
 	}
+	logger?.debug("validation", "Stack validation passed");
 
 	// 4. Generate all files
 	const files: GeneratedFiles = {};
@@ -139,6 +168,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		composeFiles: Object.keys(composeResult.files),
 		composeProfiles: composeResult.profiles,
 		openclawImage: input.openclawImage,
+		primaryFramework: input.primaryFramework,
 	});
 	files[".env.example"] = envFiles.envExample;
 	files[".env"] = envFiles.env;
@@ -165,12 +195,18 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		files[path] = content;
 	}
 
-	// OpenClaw Core Configuration
-	files["openclaw/config/openclaw.json"] = generateOpenClawConfig(resolved, {
-		deploymentType: input.deploymentType,
-		gatewayPort: 18789,
-		openclawVersion: input.openclawVersion,
-	});
+	// Framework-specific configuration
+	const framework = getFrameworkById(input.primaryFramework ?? "openclaw");
+	if (framework) {
+		const fwConfig = framework.generateConfig(resolved, {
+			deploymentType: input.deploymentType,
+			gatewayPort: 18789,
+			frameworkVersion: input.openclawVersion,
+		});
+		if (fwConfig) {
+			files[fwConfig.path] = fwConfig.content;
+		}
+	}
 
 	// README
 	files["README.md"] = generateReadme(resolved, {
@@ -180,6 +216,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		deploymentType: input.deploymentType,
 		hasNativeServices: isBareMetal && nativeServices.length > 0,
 		openclawInstallMethod: input.openclawInstallMethod,
+		primaryFramework: input.primaryFramework,
 	});
 
 	// Scripts
@@ -310,6 +347,22 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 	// 5. Calculate metadata
 	const skillCount = resolved.services.reduce((sum, s) => sum + s.definition.skills.length, 0);
 
+	const fileCount = Object.keys(files).length;
+
+	logger?.log({
+		level: "info",
+		category: "generation",
+		message: `Stack generation complete: ${fileCount} files, ${resolved.services.length} services`,
+		outcome: "success",
+		context: {
+			fileCount,
+			serviceCount: resolved.services.length,
+			skillCount,
+			estimatedMemoryMB: resolved.estimatedMemoryMB,
+		},
+		filesAffected: { created: Object.keys(files) },
+	});
+
 	return {
 		files,
 		metadata: {

package/src/generators/caddy.test.ts

@@ -19,7 +19,7 @@ describe("generateCaddyfile (via generate)", () => {
 		const result = generate(baseInput);
 
 		expect(result.files).toHaveProperty("caddy/Caddyfile");
-		expect(result.files["caddy/Caddyfile"]!.length).toBeGreaterThan(0);
+		expect(result.files["caddy/Caddyfile"]?.length).toBeGreaterThan(0);
 	});
 
 	it("does not generate Caddyfile when proxy is none", () => {
@@ -53,4 +53,44 @@ describe("generateCaddyfile (via generate)", () => {
 		// Caddy auto-enables TLS, so should reference HTTPS or TLS
 		expect(caddyfile.length).toBeGreaterThan(50);
 	});
+
+	it("adds flush_interval -1 for WebSocket-enabled services (opensandbox)", () => {
+		const result = generate({
+			...baseInput,
+			services: ["opensandbox"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("opensandbox");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("adds flush_interval -1 for desktop-environment (KasmVNC)", () => {
+		const result = generate({
+			...baseInput,
+			services: ["desktop-environment"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("desktop-environment");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("adds flush_interval -1 for agent-browser viewport streaming port", () => {
+		const result = generate({
+			...baseInput,
+			services: ["agent-browser"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("agent-browser");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("does NOT add flush_interval for non-WebSocket services", () => {
+		const result = generate(baseInput);
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).not.toContain("flush_interval");
+	});
 });

package/src/generators/caddy.ts

@@ -40,6 +40,8 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 		const primaryPort = exposedPorts[0]!;
 		const subdomain = `${definition.id}.${domain}`;
 
+		const needsWebSocket = primaryPort.websocket === true;
+
 		const block = [
 			`# ${definition.icon} ${definition.name}`,
 			`# ${definition.description}`,
@@ -49,9 +51,15 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 			`		header_up X-Real-IP {remote_host}`,
 			`		header_up X-Forwarded-For {remote_host}`,
 			`		header_up X-Forwarded-Proto {scheme}`,
-			`	}`,
 		];
 
+		// Disable response buffering for streaming WebSocket connections (noVNC, KasmVNC)
+		if (needsWebSocket) {
+			block.push(`		flush_interval -1`);
+		}
+
+		block.push(`	}`);
+
 		// Add health check if service has one
 		if (definition.healthcheck) {
 			block.push("");
@@ -74,7 +82,13 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 
 			block.push(`# ${definition.name} — ${port.description}`);
 			block.push(`${portSubdomain} {`);
-			block.push(`	reverse_proxy ${definition.id}:${port.container}`);
+			if (port.websocket) {
+				block.push(`	reverse_proxy ${definition.id}:${port.container} {`);
+				block.push(`		flush_interval -1`);
+				block.push(`	}`);
+			} else {
+				block.push(`	reverse_proxy ${definition.id}:${port.container}`);
+			}
 			block.push(`}`);
 			block.push("");
 		}

package/src/generators/clone-repos.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { generateCloneScripts } from "./clone-repos.js";
 import type { ResolverOutput } from "../types.js";
+import { generateCloneScripts } from "./clone-repos.js";
 
 /** Minimal resolved output with no services */
 function emptyResolved(): ResolverOutput {

package/src/generators/clone-repos.ts

@@ -22,7 +22,10 @@ export function generateCloneScripts(resolved: ResolverOutput): Record<string, s
 			let block = `clone_or_update "${s.definition.id}" "${gs.repoUrl}" ${branchArg}`;
 			if (gs.postCloneCommands && gs.postCloneCommands.length > 0) {
 				const cmds = gs.postCloneCommands
-					.map((cmd) => `  (cd "$REPOS_DIR/${s.definition.id}${gs.subdirectory ? `/${gs.subdirectory}` : ""}" && ${cmd})`)
+					.map(
+						(cmd) =>
+							`  (cd "$REPOS_DIR/${s.definition.id}${gs.subdirectory ? `/${gs.subdirectory}` : ""}" && ${cmd})`,
+					)
 					.join("\n");
 				block += `\n${cmds}`;
 			}
@@ -96,7 +99,9 @@ ok "All repositories ready."
 			if (gs.postCloneCommands && gs.postCloneCommands.length > 0) {
 				const subdir = gs.subdirectory ? `/${gs.subdirectory}` : "";
 				const cmds = gs.postCloneCommands
-					.map((cmd) => `Push-Location "$ReposDir/${s.definition.id}${subdir}"; ${cmd}; Pop-Location`)
+					.map(
+						(cmd) => `Push-Location "$ReposDir/${s.definition.id}${subdir}"; ${cmd}; Pop-Location`,
+					)
 					.join("\n");
 				block += `\n${cmds}`;
 			}

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/env.test.ts

@@ -37,8 +37,8 @@ describe("generateEnvFiles (via generate)", () => {
 		const redisLine = env.split("\n").find((l) => l.startsWith("REDIS_PASSWORD="));
 		expect(redisLine).toBeDefined();
 		// Value should not be empty
-		const value = redisLine!.split("=")[1];
-		expect(value!.length).toBeGreaterThan(0);
+		const value = redisLine?.split("=")[1];
+		expect(value?.length).toBeGreaterThan(0);
 	});
 
 	it("env files contain service-specific variables", () => {