@better-openclaw/core 1.0.26 → 1.0.30

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,

package/src/services/definitions/chromadb.ts

@@ -37,7 +37,7 @@ export const chromadbDefinition: ServiceDefinition = {
 	restartPolicy: "unless-stopped",
 	networks: ["openclaw-network"],
 
-	skills: [],
+	skills: [{ skillId: "chromadb-memory", autoInstall: true }],
 	openclawEnvVars: [
 		{
 			key: "CHROMADB_HOST",

package/src/services/definitions/claude-code.ts

@@ -5,7 +5,7 @@ export const claudeCodeDefinition: ServiceDefinition = {
 	name: "Claude Code",
 	description:
 		"Anthropic's agentic coding assistant that runs in the terminal. Claude Code understands your entire codebase, executes commands, and helps with complex multi-file edits.",
-	category: "coding-agent",
+	category: "agent-framework",
 	icon: "🟣",
 
 	image: "ghcr.io/zeeno-atl/claude-code",

package/src/services/definitions/clawrouter.ts

@@ -0,0 +1,141 @@
+import type { ServiceDefinition } from "../../types.js";
+
+export const clawrouterDefinition: ServiceDefinition = {
+	id: "clawrouter",
+	name: "ClawRouter",
+	description:
+		"Smart LLM router that classifies queries and routes to the cheapest capable model across 41+ options (OpenAI, Anthropic, Google, DeepSeek, xAI, and more). Exposes an OpenAI-compatible proxy with intelligent cost optimization.",
+	category: "ai",
+	icon: "🔀",
+
+	gitSource: {
+		repoUrl: "https://github.com/diopisemou/ClawRouter.git",
+		branch: "main",
+		postCloneCommands: [],
+	},
+	buildContext: {
+		dockerfile: "Dockerfile",
+		context: ".",
+	},
+
+	ports: [
+		{
+			host: 8402,
+			container: 8402,
+			description: "ClawRouter proxy (OpenAI-compatible API)",
+			exposed: true,
+		},
+	],
+	volumes: [
+		{
+			name: "clawrouter-data",
+			containerPath: "/root/.openclaw/blockrun",
+			description: "Wallet, usage logs, and configuration",
+		},
+	],
+	environment: [
+		{
+			key: "CLAWROUTER_DIRECT_KEY_MODE",
+			defaultValue: "true",
+			secret: false,
+			description: "Bypass x402 payments and use provider API keys directly",
+			required: false,
+		},
+		{
+			key: "BLOCKRUN_PROXY_PORT",
+			defaultValue: "8402",
+			secret: false,
+			description: "Proxy listen port",
+			required: false,
+		},
+		{
+			key: "OPENAI_API_KEY",
+			defaultValue: "${OPENAI_API_KEY}",
+			secret: true,
+			description: "OpenAI API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "ANTHROPIC_API_KEY",
+			defaultValue: "${ANTHROPIC_API_KEY}",
+			secret: true,
+			description: "Anthropic API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "GOOGLE_API_KEY",
+			defaultValue: "${GOOGLE_API_KEY}",
+			secret: true,
+			description: "Google API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "XAI_API_KEY",
+			defaultValue: "${XAI_API_KEY}",
+			secret: true,
+			description: "xAI API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "DEEPSEEK_API_KEY",
+			defaultValue: "${DEEPSEEK_API_KEY}",
+			secret: true,
+			description: "DeepSeek API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "GROQ_API_KEY",
+			defaultValue: "${GROQ_API_KEY}",
+			secret: true,
+			description: "Groq API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "MISTRAL_API_KEY",
+			defaultValue: "${MISTRAL_API_KEY}",
+			secret: true,
+			description: "Mistral API key (for direct-key routing)",
+			required: false,
+		},
+		{
+			key: "TOGETHER_API_KEY",
+			defaultValue: "${TOGETHER_API_KEY}",
+			secret: true,
+			description: "Together AI API key (for direct-key routing)",
+			required: false,
+		},
+	],
+	healthcheck: {
+		test: "wget -q --spider http://localhost:8402/health || exit 1",
+		interval: "30s",
+		timeout: "10s",
+		retries: 3,
+		startPeriod: "15s",
+	},
+	dependsOn: [],
+	restartPolicy: "unless-stopped",
+	networks: ["openclaw-network"],
+
+	skills: [],
+	openclawEnvVars: [
+		{
+			key: "CLAWROUTER_URL",
+			defaultValue: "http://clawrouter:8402",
+			secret: false,
+			description: "ClawRouter proxy URL for OpenClaw agents",
+			required: true,
+		},
+	],
+
+	docsUrl: "https://github.com/diopisemou/ClawRouter",
+	tags: ["llm", "router", "proxy", "cost-optimization", "smart-routing"],
+	maturity: "stable",
+
+	requires: [],
+	recommends: [],
+	conflictsWith: [],
+
+	minMemoryMB: 128,
+	gpuRequired: false,
+	proxyPath: "/clawrouter",
+};

package/src/services/definitions/codex.ts

@@ -5,7 +5,7 @@ export const codexDefinition: ServiceDefinition = {
 	name: "OpenAI Codex CLI",
 	description:
 		"OpenAI's lightweight coding agent that runs in the terminal. Uses OpenAI models to understand context, suggest edits, and execute commands in a sandboxed environment.",
-	category: "coding-agent",
+	category: "agent-framework",
 	icon: "🟢",
 
 	image: "node",

package/src/services/definitions/convex.ts

@@ -93,8 +93,7 @@ export const convexDefinition: ServiceDefinition = {
 			key: "CONVEX_INSTANCE_SECRET",
 			defaultValue: "${INSTANCE_SECRET}",
 			secret: true,
-			description:
-				"Convex instance secret used by Mission Control (synced with INSTANCE_SECRET)",
+			description: "Convex instance secret used by Mission Control (synced with INSTANCE_SECRET)",
 			required: false,
 		},
 	],