@better-openclaw/core 1.0.26 → 1.0.31

package/src/port-scanner.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it, vi } from "vitest";
+import { formatPortConflicts, scanPortConflicts } from "./port-scanner.js";
+import type { ServiceDefinition } from "./types.js";
+
+/**
+ * Tests for port scanner conflict detection and reassignment.
+ *
+ * We mock isPortAvailable via vi.mock to avoid actual port scanning
+ * during tests. The focus is on the conflict detection logic.
+ */
+
+// Mock the internal isPortAvailable to control port availability
+vi.mock("node:net", () => {
+	const portsInUse = new Set([80, 443, 3000]);
+
+	return {
+		default: {
+			Socket: class MockSocket {
+				connect(port: number) {
+					// Simulate: ports in portsInUse are "in use"
+					setTimeout(() => {
+						if (portsInUse.has(port)) {
+							(this as any).connectCb?.();
+						} else {
+							(this as any).errorCb?.();
+						}
+					}, 1);
+				}
+				once(event: string, cb: () => void) {
+					if (event === "connect") (this as any).connectCb = cb;
+					if (event === "error") (this as any).errorCb = cb;
+					if (event === "timeout") (this as any).timeoutCb = cb;
+				}
+				setTimeout() {}
+				removeAllListeners() {}
+				destroy() {}
+			},
+			createServer() {
+				return {
+					once(event: string, cb: (err?: Error) => void) {
+						if (event === "error") (this as any).errorCb = cb;
+					},
+					listen(_port: number, _host: string, cb: () => void) {
+						cb();
+					},
+					close(cb: () => void) {
+						cb();
+					},
+				};
+			},
+		},
+	};
+});
+
+function makeService(
+	id: string,
+	ports: { host: number; container: number; exposed: boolean; description: string }[],
+): ServiceDefinition {
+	return {
+		id,
+		name: id,
+		description: `${id} service`,
+		icon: "",
+		category: "test",
+		image: `${id}:latest`,
+		ports,
+		volumes: [],
+		environment: [],
+		dependencies: [],
+		conflicts: [],
+		skills: [],
+		memoryMB: 256,
+		docsUrl: "",
+	} as ServiceDefinition;
+}
+
+describe("formatPortConflicts", () => {
+	it("returns empty array when no reassignments", () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: true, description: "Redis" }]),
+		];
+		const reassignments = new Map();
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toEqual([]);
+	});
+
+	it("returns conflicts with suggested ports", () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: true, description: "Redis" }]),
+		];
+		const reassignments = new Map([["redis", new Map([[6379, 7379]])]]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toHaveLength(1);
+		expect(conflicts[0]).toEqual({
+			port: 6379,
+			serviceId: "redis",
+			description: "Redis",
+			suggestedPort: 7379,
+		});
+	});
+
+	it("handles multiple services with multiple port reassignments", () => {
+		const services = [
+			makeService("web", [
+				{ host: 80, container: 80, exposed: true, description: "HTTP" },
+				{ host: 443, container: 443, exposed: true, description: "HTTPS" },
+			]),
+			makeService("api", [{ host: 8080, container: 8080, exposed: true, description: "API" }]),
+		];
+		const reassignments = new Map([
+			[
+				"web",
+				new Map([
+					[80, 1080],
+					[443, 1443],
+				]),
+			],
+		]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts).toHaveLength(2);
+		expect(conflicts[0]!.port).toBe(80);
+		expect(conflicts[0]!.suggestedPort).toBe(1080);
+		expect(conflicts[1]!.port).toBe(443);
+		expect(conflicts[1]!.suggestedPort).toBe(1443);
+	});
+
+	it("uses service name as fallback when port has no description", () => {
+		const services = [
+			makeService("myapp", [{ host: 9000, container: 9000, exposed: true, description: "" }]),
+		];
+		const reassignments = new Map([["myapp", new Map([[9000, 10000]])]]);
+		const conflicts = formatPortConflicts(services, reassignments);
+		expect(conflicts[0]!.description).toBe("myapp port");
+	});
+});
+
+describe("scanPortConflicts", () => {
+	it("returns empty map for services with no ports", async () => {
+		const services = [makeService("redis", [])];
+		const result = await scanPortConflicts(services);
+		expect(result.size).toBe(0);
+	});
+
+	it("returns empty map for services with no exposed ports", async () => {
+		const services = [
+			makeService("redis", [{ host: 6379, container: 6379, exposed: false, description: "Redis" }]),
+		];
+		const result = await scanPortConflicts(services);
+		expect(result.size).toBe(0);
+	});
+
+	it("detects inter-service port conflicts", async () => {
+		// Two services claiming the same host port
+		const services = [
+			makeService("web1", [{ host: 8080, container: 80, exposed: true, description: "HTTP" }]),
+			makeService("web2", [{ host: 8080, container: 80, exposed: true, description: "HTTP" }]),
+		];
+		const result = await scanPortConflicts(services);
+
+		// First service wins, second gets reassigned
+		expect(result.has("web1")).toBe(false); // web1 keeps its port
+		expect(result.has("web2")).toBe(true); // web2 gets reassigned
+		const web2Reassignments = result.get("web2")!;
+		expect(web2Reassignments.has(8080)).toBe(true);
+		expect(web2Reassignments.get(8080)).toBeGreaterThan(8080);
+	});
+});

package/src/presets/presets.test.ts

@@ -20,10 +20,10 @@ describe("preset smoke tests", () => {
 		it(`getPresetById returns correct preset for "${preset.id}"`, () => {
 			const found = getPresetById(preset.id);
 			expect(found).toBeDefined();
-			expect(found!.id).toBe(preset.id);
-			expect(found!.name).toBe(preset.name);
-			expect(found!.services).toEqual(preset.services);
-			expect(found!.skillPacks).toEqual(preset.skillPacks);
+			expect(found?.id).toBe(preset.id);
+			expect(found?.name).toBe(preset.name);
+			expect(found?.services).toEqual(preset.services);
+			expect(found?.skillPacks).toEqual(preset.skillPacks);
 		});
 	}
 

package/src/presets/registry.test.ts

@@ -9,9 +9,9 @@ describe("preset registry", () => {
 	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([
+		expect(preset?.id).toBe("lasuite-meet");
+		expect(preset?.name).toBe("La Suite Meet");
+		expect(preset?.services).toEqual([
 			"postgresql",
 			"redis",
 			"livekit",
@@ -22,14 +22,14 @@ describe("preset registry", () => {
 			"ollama",
 			"caddy",
 		]);
-		expect(preset!.skillPacks).toEqual([]);
-		expect(preset!.estimatedMemoryMB).toBe(2048);
+		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");
+		expect(lasuite?.name).toBe("La Suite Meet");
 	});
 });

package/src/resolver.test.ts

@@ -211,7 +211,35 @@ describe("resolve", () => {
 		expect(frontendIdx).toBeGreaterThan(backendIdx);
 	});
 
-	// ── Mandatory services enforcement ──────────────────────────────────────
+	// ── Framework-conditional mandatory services ────────────────────────────
+
+	it("does NOT add convex/mission-control/tailscale when primaryFramework is zeroclaw", () => {
+		const result = resolve({ services: ["redis"], skillPacks: [], primaryFramework: "zeroclaw" });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("redis");
+		expect(ids).not.toContain("convex");
+		expect(ids).not.toContain("mission-control");
+		expect(ids).not.toContain("tailscale");
+		expect(result.isValid).toBe(true);
+	});
+
+	it("adds postgresql when primaryFramework is memu", () => {
+		const result = resolve({ services: [], skillPacks: [], primaryFramework: "memu" });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("postgresql");
+		expect(ids).not.toContain("convex");
+		expect(ids).not.toContain("mission-control");
+	});
+
+	it("defaults to openclaw mandatory services when no primaryFramework specified", () => {
+		const result = resolve({ services: ["redis"], skillPacks: [] });
+		const ids = result.services.map((s) => s.definition.id);
+		expect(ids).toContain("convex");
+		expect(ids).toContain("mission-control");
+		expect(ids).toContain("tailscale");
+	});
+
+	// ── Mandatory services enforcement (OpenClaw default) ────────────────
 
 	it("auto-includes mandatory services even when not selected", () => {
 		const result = resolve({ services: ["redis"], skillPacks: [] });
@@ -220,13 +248,13 @@ describe("resolve", () => {
 		expect(ids).toContain("convex");
 		expect(ids).toContain("tailscale");
 		const mc = result.services.find((s) => s.definition.id === "mission-control");
-		expect(mc!.addedBy).toBe("mandatory");
+		expect(mc?.addedBy).toBe("mandatory");
 	});
 
 	it("marks user-selected mandatory services as 'user' not 'mandatory'", () => {
 		const result = resolve({ services: ["mission-control"], skillPacks: [] });
 		const mc = result.services.find((s) => s.definition.id === "mission-control");
-		expect(mc!.addedBy).toBe("user");
+		expect(mc?.addedBy).toBe("user");
 		// convex should still be auto-added as dependency of mission-control
 		const convex = result.services.find((s) => s.definition.id === "convex");
 		expect(convex).toBeDefined();

package/src/resolver.ts

@@ -1,3 +1,4 @@
+import { getFrameworkById } from "./frameworks/index.js";
 import { getAllServices, getServiceById } from "./services/registry.js";
 import { getSkillPackById } from "./skills/registry.js";
 import type {
@@ -99,14 +100,28 @@ export function resolve(input: ResolverInput): ResolverOutput {
 		}
 	}
 
-	// Add mandatory platform services (mission-control, convex, tailscale, etc.)
+	// Add mandatory platform services based on selected framework
+	const framework = getFrameworkById(input.primaryFramework ?? "openclaw");
+	const frameworkMandatoryIds = new Set(framework?.getMandatoryServices() ?? []);
+
 	for (const def of getAllServices()) {
-		if (def.mandatory && !serviceIds.has(def.id)) {
+		if (!serviceIds.has(def.id) && frameworkMandatoryIds.has(def.id)) {
 			serviceIds.add(def.id);
 			serviceAddedBy.set(def.id, "mandatory");
 			addedDependencies.push({
 				service: def.id,
-				reason: "Mandatory OpenClaw platform service",
+				reason: `Required by ${framework?.name ?? "platform"}`,
+			});
+		}
+	}
+
+	// Surface framework-level recommendations for services not selected
+	const frameworkRecommendedIds = new Set(framework?.getRecommendedServices() ?? []);
+	for (const recId of frameworkRecommendedIds) {
+		if (!serviceIds.has(recId) && getServiceById(recId)) {
+			warnings.push({
+				type: "recommendation",
+				message: `${framework?.name ?? "Framework"} recommends "${recId}" for smart LLM routing and cost optimization`,
 			});
 		}
 	}
@@ -264,6 +279,7 @@ export function resolve(input: ResolverInput): ResolverOutput {
 		estimatedMemoryMB,
 		aiProviders: input.aiProviders ?? [],
 		gsdRuntimes: [],
+		primaryFramework: input.primaryFramework ?? "openclaw",
 	};
 }
 

package/src/schema.test.ts

@@ -251,8 +251,8 @@ describe("ServiceDefinitionSchema", () => {
 		const result = ServiceDefinitionSchema.parse(withNative);
 		expect(result.nativeSupported).toBe(true);
 		expect(result.nativeRecipes).toHaveLength(1);
-		expect(result.nativeRecipes![0].platform).toBe("linux");
-		expect(result.nativeRecipes![0].startCommand).toBe("systemctl start redis-server");
+		expect(result.nativeRecipes?.[0].platform).toBe("linux");
+		expect(result.nativeRecipes?.[0].startCommand).toBe("systemctl start redis-server");
 	});
 });
 

package/src/schema.ts

@@ -39,6 +39,7 @@ export const ServiceCategorySchema = z.enum([
 	"dns-networking",
 	"iot",
 	"saas-boilerplate",
+	"agent-framework",
 ]);
 
 export const MaturitySchema = z.enum(["stable", "beta", "experimental"]);
@@ -88,6 +89,17 @@ export const AiProviderSchema = z.enum([
 
 export const GsdRuntimeSchema = z.enum(["claude", "opencode", "gemini", "codex"]);
 
+export const AgentFrameworkSchema = z.enum([
+	"openclaw",
+	"copaw",
+	"nanoclaw",
+	"nanobot",
+	"zeroclaw",
+	"memu",
+	"claude-code",
+	"codex",
+]);
+
 // ─── Sub-Schemas ────────────────────────────────────────────────────────────
 
 export const PortMappingSchema = z.object({
@@ -95,6 +107,8 @@ export const PortMappingSchema = z.object({
 	container: z.number().int().min(1).max(65535),
 	description: z.string(),
 	exposed: z.boolean().default(true),
+	/** When true, Caddy adds flush_interval -1 for streaming WebSocket support (noVNC, KasmVNC) */
+	websocket: z.boolean().default(false).optional(),
 });
 
 export const VolumeMappingSchema = z.object({
@@ -228,10 +242,12 @@ export const ServiceDefinitionSchema = z.object({
 	labels: z.record(z.string(), z.string()).optional(),
 	deploy: DeploySchema.optional(),
 
-	// OpenClaw Integration
+	// Framework Integration (gatewayEnvVars/gatewayVolumeMounts are framework-agnostic aliases)
 	skills: z.array(SkillBindingSchema).default([]),
 	openclawEnvVars: z.array(EnvVariableSchema).default([]),
 	openclawVolumeMounts: z.array(VolumeMappingSchema).optional(),
+	gatewayEnvVars: z.array(EnvVariableSchema).optional(),
+	gatewayVolumeMounts: z.array(VolumeMappingSchema).optional(),
 
 	// Metadata
 	docsUrl: z.string().url(),
@@ -309,6 +325,8 @@ export const GenerationInputSchema = z.object({
 			message:
 				"Project name must be lowercase alphanumeric with hyphens, cannot start or end with hyphen",
 		}),
+	primaryFramework: AgentFrameworkSchema.optional(),
+	companionFrameworks: z.array(AgentFrameworkSchema).optional(),
 	services: z.array(z.string()).default([]),
 	skillPacks: z.array(z.string()).default([]),
 	aiProviders: z.array(AiProviderSchema).default([]),
@@ -337,7 +355,9 @@ export const GenerationInputSchema = z.object({
 
 export const ResolvedServiceSchema = z.object({
 	definition: ServiceDefinitionSchema,
-	addedBy: z.enum(["user", "dependency", "skill-pack", "proxy", "monitoring", "mandatory"]).default("user"),
+	addedBy: z
+		.enum(["user", "dependency", "skill-pack", "proxy", "monitoring", "mandatory"])
+		.default("user"),
 });
 
 export const AddedDependencySchema = z.object({
@@ -367,12 +387,15 @@ export const ResolverOutputSchema = z.object({
 	estimatedMemoryMB: z.number().int().min(0),
 	aiProviders: z.array(AiProviderSchema).default([]),
 	gsdRuntimes: z.array(GsdRuntimeSchema).default([]),
+	primaryFramework: AgentFrameworkSchema.optional(),
 });
 
 // ─── Compose Options ────────────────────────────────────────────────────────
 
 export const ComposeOptionsSchema = z.object({
 	projectName: z.string(),
+	primaryFramework: AgentFrameworkSchema.optional(),
+	companionFrameworks: z.array(AgentFrameworkSchema).optional(),
 	proxy: ProxyTypeSchema.default("none"),
 	proxyHttpPort: z.number().int().min(1).max(65535).optional(),
 	proxyHttpsPort: z.number().int().min(1).max(65535).optional(),
@@ -441,7 +464,9 @@ export const AddonStackInputSchema = z.object({
 	/** User-provided credentials for services that need them. */
 	credentials: z.record(z.string(), z.record(z.string(), z.string())).default({}),
 	/** Port overrides for specific services. */
-	portOverrides: z.record(z.string(), z.record(z.string(), z.number().int().min(1).max(65535))).optional(),
+	portOverrides: z
+		.record(z.string(), z.record(z.string(), z.number().int().min(1).max(65535)))
+		.optional(),
 	/** Whether the host has GPU support. */
 	gpu: z.boolean().default(false),
 	/** AI providers configured on this instance. */
@@ -456,15 +481,19 @@ export const AddonStackResultSchema = z.object({
 	/** Complete .env file with all secrets generated. */
 	envFile: z.string(),
 	/** Structured env vars for UI display / credential management. */
-	envVars: z.array(z.object({
-		serviceName: z.string(),
-		vars: z.array(z.object({
-			key: z.string(),
-			description: z.string(),
-			value: z.string(),
-			secret: z.boolean(),
-		})),
-	})),
+	envVars: z.array(
+		z.object({
+			serviceName: z.string(),
+			vars: z.array(
+				z.object({
+					key: z.string(),
+					description: z.string(),
+					value: z.string(),
+					secret: z.boolean(),
+				}),
+			),
+		}),
+	),
 	/** SKILL.md files keyed by slug. */
 	skillFiles: z.record(z.string(), z.string()),
 	/** OpenClaw config additions (skills.entries to merge). */
@@ -487,10 +516,14 @@ export const AddonStackResultSchema = z.object({
 		generatedSecretKeys: z.array(z.string()),
 		portAssignments: z.record(z.string(), z.number()),
 		/** Docker images to pre-pull during cloud-init, grouped by priority. */
-		prePullImages: z.array(z.object({
-			image: z.string(),
-			priority: z.union([z.literal(1), z.literal(2), z.literal(3)]),
-		})).default([]),
+		prePullImages: z
+			.array(
+				z.object({
+					image: z.string(),
+					priority: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+				}),
+			)
+			.default([]),
 	}),
 	/** Warnings (non-fatal issues). */
 	warnings: z.array(z.string()),
@@ -511,11 +544,17 @@ export const AddonStackUpdateInputSchema = z.object({
 	/** User-provided credentials for new services. */
 	credentials: z.record(z.string(), z.record(z.string(), z.string())).default({}),
 	/** Port overrides for specific services. */
-	portOverrides: z.record(z.string(), z.record(z.string(), z.number().int().min(1).max(65535))).optional(),
+	portOverrides: z
+		.record(z.string(), z.record(z.string(), z.number().int().min(1).max(65535)))
+		.optional(),
+	/** Services already running on the instance (to detect conflicts). */
+	existingServices: z.array(z.string()).default([]),
 	/** Reserved ports. */
 	reservedPorts: z.array(z.number().int()).default([]),
 	platform: PlatformSchema.default("linux/amd64"),
 	openclawVersion: z.string().default("latest"),
+	/** Whether the host has GPU support. */
+	gpu: z.boolean().default(false),
 	aiProviders: z.array(AiProviderSchema).default([]),
 	prebuiltImages: z.record(z.string(), z.string()).default({}),
 });
@@ -561,6 +600,8 @@ export const ValidateRequestSchema = z.object({
 	skillPacks: z.array(z.string()).default([]),
 	aiProviders: z.array(AiProviderSchema).default([]),
 	gsdRuntimes: z.array(GsdRuntimeSchema).default([]),
+	primaryFramework: AgentFrameworkSchema.optional(),
+	companionFrameworks: z.array(AgentFrameworkSchema).optional(),
 	proxy: ProxyTypeSchema.default("none"),
 	domain: z.string().optional(),
 	gpu: z.boolean().default(false),

package/src/services/definitions/agent-browser.ts

@@ -0,0 +1,177 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const agentBrowserDefinition: ServiceDefinition = {
+	id: "agent-browser",
+	name: "Agent Browser",
+	description:
+		"AI-optimized headless browser by Vercel Labs. Rust-native CLI with snapshot + ref workflow (@e1, @e2) for deterministic LLM element targeting, content boundaries for prompt injection safety, action policies, and live WebSocket viewport streaming.",
+	category: "browser",
+	icon: "🌍",
+
+	// Thin Docker wrapper — npx downloads the pre-compiled Rust binary + Chrome for Testing
+	image: "node",
+	imageTag: "22-slim",
+	command:
+		'sh -c "npx -y agent-browser@latest install --yes 2>/dev/null; exec npx -y agent-browser@latest daemon --port 9222"',
+	ports: [
+		{
+			host: 9224,
+			container: 9222,
+			description: "CDP protocol (Chrome DevTools Protocol)",
+			exposed: true,
+		},
+		{
+			host: 9223,
+			container: 9223,
+			description: "Viewport streaming WebSocket (pair browsing)",
+			exposed: true,
+			websocket: true,
+		},
+	],
+	volumes: [
+		{
+			name: "agent-browser-data",
+			containerPath: "/root/.agent-browser",
+			description: "Agent Browser session state, auth vault, and configuration",
+		},
+	],
+	environment: [
+		{
+			key: "AGENT_BROWSER_JSON",
+			defaultValue: "true",
+			secret: false,
+			description: "JSON output mode for AI agent parsing",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_CONTENT_BOUNDARIES",
+			defaultValue: "true",
+			secret: false,
+			description: "Wrap page output in boundary markers to prevent LLM prompt injection",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_DEFAULT_TIMEOUT",
+			defaultValue: "25000",
+			secret: false,
+			description: "Default operation timeout in milliseconds",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_STREAM_PORT",
+			defaultValue: "9223",
+			secret: false,
+			description: "WebSocket port for live viewport streaming (pair browsing)",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_IDLE_TIMEOUT_MS",
+			defaultValue: "3600000",
+			secret: false,
+			description: "Auto-shutdown daemon after inactivity (ms, default 1 hour)",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_ALLOWED_DOMAINS",
+			defaultValue: "",
+			secret: false,
+			description:
+				"Comma-separated domain allowlist for security (e.g. example.com,*.github.com). Empty = all domains allowed",
+			required: false,
+		},
+		{
+			key: "AGENT_BROWSER_ENCRYPTION_KEY",
+			defaultValue: "",
+			secret: true,
+			description: "64-character hex key for AES-256-GCM encryption of browser auth state",
+			required: false,
+		},
+	],
+	healthcheck: {
+		test: "npx -y agent-browser@latest --version || exit 1",
+		interval: "30s",
+		timeout: "15s",
+		retries: 3,
+		startPeriod: "60s",
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	skills: [{ skillId: "agent-browse", autoInstall: true }],
+	openclawEnvVars: [
+		{
+			key: "AGENT_BROWSER_HOST",
+			defaultValue: "agent-browser",
+			secret: false,
+			description: "Agent Browser hostname for OpenClaw",
+			required: true,
+		},
+		{
+			key: "AGENT_BROWSER_CDP_PORT",
+			defaultValue: "9224",
+			secret: false,
+			description: "Agent Browser CDP port for OpenClaw",
+			required: true,
+		},
+		{
+			key: "AGENT_BROWSER_STREAM_PORT",
+			defaultValue: "9223",
+			secret: false,
+			description: "Agent Browser viewport streaming WebSocket port",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://github.com/vercel/agent-browser",
+	tags: [
+		"ai-agent",
+		"browser",
+		"cdp",
+		"rust",
+		"snapshot",
+		"refs",
+		"automation",
+		"streaming",
+		"vercel",
+		"headless",
+	],
+	maturity: "beta",
+
+	requires: [],
+	recommends: ["browserless"],
+	conflictsWith: [],
+
+	minMemoryMB: 512,
+	gpuRequired: false,
+
+	// Bare-metal native recipes — agent-browser is designed to run on the host
+	nativeSupported: true,
+	nativeRecipes: [
+		{
+			platform: "linux",
+			installSteps: [
+				"command -v agent-browser >/dev/null 2>&1 || (npm install -g agent-browser && agent-browser install --yes)",
+			],
+			startCommand: "agent-browser daemon --port 9222 &",
+			stopCommand: "pkill -f 'agent-browser daemon' 2>/dev/null",
+		},
+		{
+			platform: "macos",
+			installSteps: [
+				"command -v agent-browser >/dev/null 2>&1 || (brew install agent-browser 2>/dev/null || npm install -g agent-browser) && agent-browser install --yes",
+			],
+			startCommand: "agent-browser daemon --port 9222 &",
+			stopCommand: "pkill -f 'agent-browser daemon' 2>/dev/null",
+		},
+		{
+			platform: "windows",
+			installSteps: [
+				"if (-not (Get-Command agent-browser -ErrorAction SilentlyContinue)) { npm install -g agent-browser; agent-browser install --yes }",
+			],
+			startCommand:
+				"Start-Process -NoNewWindow agent-browser -ArgumentList 'daemon','--port','9222'",
+			stopCommand: "Stop-Process -Name agent-browser -Force -ErrorAction SilentlyContinue",
+		},
+	],
+};

package/src/services/definitions/apptension-saas.ts

@@ -37,7 +37,8 @@ export const apptensionSaasDefinition: ServiceDefinition = {
 		},
 		{
 			key: "DB_CONNECTION",
-			defaultValue: "postgresql://apptensionsaas:${APPTENSION_SAAS_DB_PASSWORD}@postgresql:5432/apptensionsaas",
+			defaultValue:
+				"postgresql://apptensionsaas:${APPTENSION_SAAS_DB_PASSWORD}@postgresql:5432/apptensionsaas",
 			secret: false,
 			description: "PostgreSQL connection string",
 			required: true,