@plitzi/sdk-server 0.30.19 → 0.31.0

package/dist/modules/mcp/tools/space/schema/elements/moveElement.js

@@ -0,0 +1,27 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/moveElement.ts
+var moveElementTool = {
+	name: "move_element",
+	adapterName: "moveElement",
+	mcpDefinition: {
+		title: "Move Element",
+		description: "Move an element to a different parent or reorder it within its current parent.",
+		inputSchema: z.object({
+			elementId: z.string().describe("ID of the element to move"),
+			toParentId: z.string().describe("ID of the new parent element"),
+			dropPosition: z.enum([
+				"top",
+				"bottom",
+				"left",
+				"right",
+				"inside",
+				"custom"
+			]).optional().describe("Where to drop relative to the target parent: \"inside\" appends as last child (default), \"top\"/\"bottom\" inserts before/after siblings")
+		}),
+		outputSchema: z.literal(true).describe("Always true on successful move")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { moveElementTool as default };

package/dist/modules/mcp/tools/space/schema/elements/updateElement.js

@@ -0,0 +1,49 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/elements/updateElement.ts
+var elementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	attributes: z.record(z.string(), z.unknown()).describe("Element attributes"),
+	definition: z.object({
+		rootId: z.string().describe("Root element ID"),
+		label: z.string().describe("Element label"),
+		type: z.string().describe("Element type"),
+		parentId: z.string().optional().describe("Parent element ID"),
+		items: z.array(z.string()).optional().describe("Child element IDs"),
+		runtime: z.enum([
+			"server",
+			"client",
+			"shared"
+		]).optional().describe("Rendering runtime"),
+		loadStrategy: z.enum([
+			"eager",
+			"lazy",
+			"visible"
+		]).optional().describe("Load strategy")
+	}).describe("Element definition")
+});
+var updateElementTool = {
+	name: "update_element",
+	adapterName: "updateElement",
+	mcpDefinition: {
+		title: "Update Element",
+		description: "Update an existing element — label, props, or rendering runtime.",
+		inputSchema: z.object({
+			elementId: z.string().describe("ID of the element to update"),
+			updates: z.object({
+				label: z.string().optional().describe("New label for the element"),
+				props: z.record(z.string(), z.unknown()).optional().describe("New props for the element"),
+				styles: z.record(z.string(), z.unknown()).optional().describe("Style attribute overrides keyed by sub-selector slot (e.g. { base: { color: \"#fff\" } }). Rarely needed — prefer update_style_selector to modify styles."),
+				runtime: z.enum([
+					"server",
+					"client",
+					"shared"
+				]).optional().describe("New rendering runtime")
+			}).describe("Fields to update")
+		}),
+		outputSchema: elementSchema.describe("The updated element")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateElementTool as default };

package/dist/modules/mcp/tools/space/schema/getSpaceSettings.js

@@ -0,0 +1,46 @@
+import { getAllowedModes } from "../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/getSpaceSettings.ts
+var getSpaceSettingsTool = {
+	name: "get_space_settings",
+	adapterName: "getSpaceSettings",
+	mcpDefinition: {
+		title: "Get Space Settings",
+		description: "Read the current space settings — custom CSS, authentication provider, state storage, and other configuration.\n\nUse before update_space_settings to understand the current configuration.",
+		inputSchema: z.object({}),
+		outputSchema: z.object({
+			customCss: z.string().optional().describe("Custom CSS injected into every page"),
+			keepState: z.boolean().optional().describe("Persist UI state across navigation"),
+			stateStorage: z.enum([
+				"localStorage",
+				"sessionStorage",
+				""
+			]).nullable().optional().describe("State storage mechanism"),
+			userProvider: z.enum([
+				"auth0",
+				"basic",
+				"custom",
+				""
+			]).optional().describe("Authentication provider"),
+			auth0Domain: z.string().optional(),
+			auth0ClientId: z.string().optional(),
+			tokenStorage: z.enum([
+				"localStorage",
+				"sessionStorage",
+				""
+			]).optional(),
+			loginUrl: z.string().optional(),
+			userUrl: z.string().optional(),
+			refreshUrl: z.string().optional(),
+			logoutUrl: z.string().optional(),
+			detailsPath: z.string().optional(),
+			tokenPath: z.string().optional(),
+			refreshTokenPath: z.string().optional(),
+			expirationTimePath: z.string().optional(),
+			head: z.string().optional()
+		}).nullable().describe("Current space settings, or null if space not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getSpaceSettingsTool as default };

package/dist/modules/mcp/tools/space/schema/pageFolders/createPageFolder.js

@@ -0,0 +1,24 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pageFolders/createPageFolder.ts
+var createPageFolderTool = {
+	name: "create_page_folder",
+	adapterName: "createPageFolder",
+	mcpDefinition: {
+		title: "Create Page Folder",
+		description: "Create a new page folder to organize pages.",
+		inputSchema: z.object({
+			name: z.string().describe("Name of the page folder"),
+			parentId: z.string().optional().describe("Parent folder ID — omit to create a top-level folder")
+		}),
+		outputSchema: z.object({
+			id: z.string().describe("Folder ID"),
+			name: z.string().describe("Folder name"),
+			slug: z.string().describe("Folder slug"),
+			parentId: z.string().optional().describe("Parent folder ID")
+		}).describe("The created page folder")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createPageFolderTool as default };

package/dist/modules/mcp/tools/space/schema/pageFolders/deletePageFolder.js

@@ -0,0 +1,16 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pageFolders/deletePageFolder.ts
+var deletePageFolderTool = {
+	name: "delete_page_folder",
+	adapterName: "deletePageFolder",
+	mcpDefinition: {
+		title: "Delete Page Folder",
+		description: "Delete a page folder. Pages inside are moved to root.",
+		inputSchema: z.object({ id: z.string().describe("Page folder ID to delete") }),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deletePageFolderTool as default };

package/dist/modules/mcp/tools/space/schema/pageFolders/getPageFolder.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { pageFolderSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pageFolders/getPageFolder.ts
+var getPageFolderTool = {
+	name: "get_page_folder",
+	adapterName: "getPageFolder",
+	mcpDefinition: {
+		title: "Get Page Folder",
+		description: "Get a specific page folder by ID.\n\nUse get_page_folders to list all available folder IDs first if you do not know the target folder ID.",
+		inputSchema: z.object({ folderId: z.string().describe("ID of the page folder to retrieve") }),
+		outputSchema: pageFolderSchema.nullable().describe("The page folder, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getPageFolderTool as default };

package/dist/modules/mcp/tools/space/schema/pageFolders/getPageFolders.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { pageFolderSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pageFolders/getPageFolders.ts
+var getPageFoldersTool = {
+	name: "get_page_folders",
+	adapterName: "getPageFolders",
+	mcpDefinition: {
+		title: "Get Page Folders",
+		description: "List all page folders in the space.\n\nPage folders organize pages into a hierarchy. Each folder has a name, slug, and optional parentId for nesting. Pages reference their folder via the folder attribute in their element attributes.",
+		inputSchema: z.object({}),
+		outputSchema: z.array(pageFolderSchema).describe("All page folders in the space")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getPageFoldersTool as default };

package/dist/modules/mcp/tools/space/schema/pageFolders/updatePageFolder.js

@@ -0,0 +1,28 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pageFolders/updatePageFolder.ts
+var updatePageFolderTool = {
+	name: "update_page_folder",
+	adapterName: "updatePageFolder",
+	mcpDefinition: {
+		title: "Update Page Folder",
+		description: "Rename a page folder or move it to a different parent folder.",
+		inputSchema: z.object({
+			id: z.string().describe("Page folder ID"),
+			updates: z.object({
+				name: z.string().optional().describe("New name for the folder"),
+				slug: z.string().optional().describe("New slug for the folder"),
+				parentId: z.string().optional().describe("New parent folder ID")
+			}).describe("Fields to update")
+		}),
+		outputSchema: z.object({
+			id: z.string().describe("Folder ID"),
+			name: z.string().describe("Folder name"),
+			slug: z.string().describe("Folder slug"),
+			parentId: z.string().optional().describe("Parent folder ID")
+		}).describe("The updated page folder")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updatePageFolderTool as default };

package/dist/modules/mcp/tools/space/schema/pages/createPage.js

@@ -0,0 +1,37 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/createPage.ts
+var elementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	attributes: z.record(z.string(), z.unknown()).describe("Element attributes"),
+	definition: z.object({
+		rootId: z.string().describe("Root element ID"),
+		label: z.string().describe("Element label"),
+		type: z.string().describe("Element type"),
+		parentId: z.string().optional().describe("Parent element ID"),
+		items: z.array(z.string()).optional().describe("Child element IDs"),
+		runtime: z.enum([
+			"server",
+			"client",
+			"shared"
+		]).optional().describe("Rendering runtime"),
+		loadStrategy: z.enum([
+			"eager",
+			"lazy",
+			"visible"
+		]).optional().describe("Load strategy")
+	}).describe("Element definition")
+});
+var createPageTool = {
+	name: "create_page",
+	adapterName: "createPage",
+	mcpDefinition: {
+		title: "Create Page",
+		description: "Create a new page in the space. Returns the page element — use its id to add child elements via create_element.",
+		inputSchema: z.object({ name: z.string().describe("Name of the page to create") }),
+		outputSchema: elementSchema.describe("The created page")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createPageTool as default };

package/dist/modules/mcp/tools/space/schema/pages/deletePage.js

@@ -0,0 +1,16 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/deletePage.ts
+var deletePageTool = {
+	name: "delete_page",
+	adapterName: "deletePage",
+	mcpDefinition: {
+		title: "Delete Page",
+		description: "Delete a page and all its child elements. This action cannot be undone.",
+		inputSchema: z.object({ pageId: z.string().describe("ID of the page to delete") }),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deletePageTool as default };

package/dist/modules/mcp/tools/space/schema/pages/getPage.js

@@ -0,0 +1,28 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/getPage.ts
+var inputSchema = z.object({ pageId: z.string().describe("ID of the page to retrieve") });
+var pageElementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	label: z.string().describe("Human-readable element label"),
+	type: z.string().describe("Element type (e.g. \"button\", \"text\", \"box\")"),
+	parentId: z.string().nullable().describe("Parent element ID, or null for root elements"),
+	attributes: z.record(z.string(), z.unknown()).describe("Element attributes/props — includes its current content, text, classes, etc.")
+});
+var getPageTool = {
+	name: "get_page",
+	adapterName: "getPage",
+	mcpDefinition: {
+		title: "Get Page",
+		description: "Get a page by ID — returns the page element and every element on it (id, label, type, parentId and current attributes). Usually enough to find an element and read or change its content/props without further calls. Use get_pages to find available page IDs; get_element only for one element in isolation.",
+		inputSchema,
+		outputSchema: z.object({
+			page: elementSchema.describe("The page element with its attributes (slug, name, default, folder)"),
+			elements: z.array(pageElementSchema).describe("Every element on the page with its label, type, parent and current attributes")
+		}).nullable().describe("Page info and its elements, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getPageTool as default };

package/dist/modules/mcp/tools/space/schema/pages/getPageBySlug.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/getPageBySlug.ts
+var getPageBySlugTool = {
+	name: "get_page_by_slug",
+	adapterName: "getPageBySlug",
+	mcpDefinition: {
+		title: "Get Page By Slug",
+		description: "Find a page by its URL slug.\n\nUseful when you know the route path but not the element ID. Use get_pages to list all pages with their slugs.",
+		inputSchema: z.object({ slug: z.string().describe("URL slug of the page to find (e.g. \"about-us\")") }),
+		outputSchema: elementSchema.nullable().describe("The matching page element, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getPageBySlugTool as default };

package/dist/modules/mcp/tools/space/schema/pages/getPages.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/getPages.ts
+var getPagesTool = {
+	name: "get_pages",
+	adapterName: "getPages",
+	mcpDefinition: {
+		title: "Get Pages",
+		description: "List all pages in the space.\n\nEach page is an element with type \"page\". Page attributes include slug, name, default, and folder (folder ID). Use get_page to fetch a specific page with its full element tree.",
+		inputSchema: z.object({}),
+		outputSchema: z.array(elementSchema).describe("All page elements in the space")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getPagesTool as default };

package/dist/modules/mcp/tools/space/schema/pages/updatePage.js

@@ -0,0 +1,25 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { elementSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/pages/updatePage.ts
+var updatePageTool = {
+	name: "update_page",
+	adapterName: "updatePage",
+	mcpDefinition: {
+		title: "Update Page",
+		description: "Update page metadata — name, slug, default status, or folder assignment.\n\nTo set a page as the home/default page, pass default: true. Use get_pages to list all pages and their current slugs before updating.",
+		inputSchema: z.object({
+			pageId: z.string().describe("ID of the page to update"),
+			updates: z.object({
+				name: z.string().optional().describe("New display name for the page"),
+				slug: z.string().optional().describe("New URL slug (e.g. \"about-us\")"),
+				default: z.boolean().optional().describe("Set true to make this the default/home page"),
+				folder: z.string().optional().describe("ID of the page folder to assign this page to")
+			}).describe("Fields to update on the page")
+		}),
+		outputSchema: elementSchema.describe("The updated page element")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updatePageTool as default };

package/dist/modules/mcp/tools/space/schema/schemas.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/schemas.ts
+var elementDefinitionSchema = z.object({
+	rootId: z.string().describe("Root element ID"),
+	label: z.string().describe("Element label"),
+	type: z.string().describe("Element type"),
+	parentId: z.string().nullish().describe("Parent element ID (null for root elements)"),
+	items: z.array(z.string()).nullable().describe("Child element IDs"),
+	runtime: z.enum([
+		"server",
+		"client",
+		"shared"
+	]).optional().describe("Rendering runtime"),
+	loadStrategy: z.enum([
+		"eager",
+		"lazy",
+		"visible"
+	]).optional().describe("Load strategy")
+}).describe("Element definition");
+var elementSchema = z.object({
+	id: z.string().describe("Element ID"),
+	attributes: z.record(z.string(), z.unknown()).describe("Element attributes"),
+	definition: elementDefinitionSchema
+});
+var pageFolderSchema = z.object({
+	id: z.string().describe("Folder ID"),
+	name: z.string().describe("Folder name"),
+	slug: z.string().describe("Folder slug"),
+	parentId: z.string().nullish().describe("Parent folder ID (null for root folders)")
+});
+var schemaVariableSchema = z.object({
+	name: z.string().describe("Variable name"),
+	category: z.string().nullable().describe("Variable category"),
+	type: z.enum([
+		"text",
+		"number",
+		"email",
+		"password",
+		"select",
+		"select2",
+		"checkbox",
+		"textarea",
+		"color",
+		"switch"
+	]).describe("Variable type"),
+	value: z.string().describe("Default value"),
+	subValues: z.array(z.object({
+		when: z.record(z.string(), z.unknown()),
+		value: z.string()
+	})).describe("Conditional sub-values")
+});
+//#endregion
+export { elementSchema, pageFolderSchema, schemaVariableSchema };

package/dist/modules/mcp/tools/space/schema/updateSpaceSettings.js

@@ -0,0 +1,23 @@
+import { getAllowedModes } from "../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/updateSpaceSettings.ts
+var updateSpaceSettingsTool = {
+	name: "update_space_settings",
+	adapterName: "updateSpaceSettings",
+	mcpDefinition: {
+		title: "Update Space Settings",
+		description: "Update a space setting at a specific path using dot notation.\n\nExamples: set customCss with path=\"customCss\", set auth provider with path=\"userProvider\" value=\"auth0\". Use get_space_settings first to read the current configuration.",
+		inputSchema: z.object({
+			path: z.string().optional().describe("Dot-notation path to the setting to update (e.g. \"customCss\", \"auth0Domain\"). Omit to replace all settings."),
+			value: z.union([
+				z.string(),
+				z.number(),
+				z.boolean()
+			]).optional().describe("New value for the setting at the given path")
+		}),
+		outputSchema: z.record(z.string(), z.unknown()).describe("Updated settings object")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateSpaceSettingsTool as default };

package/dist/modules/mcp/tools/space/schema/variables/createVariable.js

@@ -0,0 +1,38 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/variables/createVariable.ts
+var variableTypesSchema = z.enum([
+	"text",
+	"number",
+	"email",
+	"password",
+	"select",
+	"select2",
+	"checkbox",
+	"textarea",
+	"color",
+	"switch"
+]);
+var createVariableTool = {
+	name: "create_variable",
+	adapterName: "createSchemaVariable",
+	mcpDefinition: {
+		title: "Create Variable",
+		description: "Create a space-level schema variable — a typed, named value that elements can reference via data bindings.\n\nUse category to group related variables in the builder UI (e.g. \"Colors\", \"Typography\"). All values are stored as strings regardless of type.",
+		inputSchema: z.object({ variable: z.object({
+			name: z.string().describe("Variable name"),
+			type: variableTypesSchema.describe("Variable type"),
+			value: z.string().describe("Variable default value"),
+			category: z.string().describe("Grouping label shown in the builder UI (e.g. \"Colors\", \"Typography\", \"Layout\")")
+		}).describe("Variable to create") }),
+		outputSchema: z.object({
+			name: z.string().describe("Variable name"),
+			type: z.string().describe("Variable type"),
+			value: z.string().describe("Variable value"),
+			category: z.string().describe("Grouping label shown in the builder UI (e.g. \"Colors\", \"Typography\", \"Layout\")")
+		}).describe("The created variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createVariableTool as default };

package/dist/modules/mcp/tools/space/schema/variables/deleteVariable.js

@@ -0,0 +1,16 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/variables/deleteVariable.ts
+var deleteVariableTool = {
+	name: "delete_variable",
+	adapterName: "deleteSchemaVariable",
+	mcpDefinition: {
+		title: "Delete Variable",
+		description: "Delete a schema variable. Any element bindings referencing this variable will break.",
+		inputSchema: z.object({ name: z.string().describe("Name of the variable to delete") }),
+		outputSchema: z.literal(true).describe("Always true on successful deletion")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { deleteVariableTool as default };

package/dist/modules/mcp/tools/space/schema/variables/getVariable.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { schemaVariableSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/variables/getVariable.ts
+var getVariableTool = {
+	name: "get_variable",
+	adapterName: "getVariable",
+	mcpDefinition: {
+		title: "Get Variable",
+		description: "Get a specific schema variable by name.\n\nSchema variables are space-level typed values that elements can reference via data bindings. Use get_variables to list all available variable names first if needed.",
+		inputSchema: z.object({ name: z.string().describe("Name of the variable to retrieve") }),
+		outputSchema: schemaVariableSchema.nullable().describe("The variable, or null if not found")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getVariableTool as default };

package/dist/modules/mcp/tools/space/schema/variables/getVariables.js

@@ -0,0 +1,17 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { schemaVariableSchema } from "../schemas.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/variables/getVariables.ts
+var getVariablesTool = {
+	name: "get_variables",
+	adapterName: "getVariables",
+	mcpDefinition: {
+		title: "Get Variables",
+		description: "List all schema variables in the space.\n\nSchema variables are space-level typed values (text, color, number, etc.) that elements can reference via data bindings. Use get_variable to retrieve a single variable by name.",
+		inputSchema: z.object({}),
+		outputSchema: z.array(schemaVariableSchema).describe("All schema variables in the space")
+	},
+	definition: { allowedModes: getAllowedModes("read") }
+};
+//#endregion
+export { getVariablesTool as default };

package/dist/modules/mcp/tools/space/schema/variables/updateVariable.js

@@ -0,0 +1,38 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/schema/variables/updateVariable.ts
+var variableTypesSchema = z.enum([
+	"text",
+	"number",
+	"email",
+	"password",
+	"select",
+	"select2",
+	"checkbox",
+	"textarea",
+	"color",
+	"switch"
+]);
+var updateVariableTool = {
+	name: "update_variable",
+	adapterName: "updateSchemaVariable",
+	mcpDefinition: {
+		title: "Update Variable",
+		description: "Update an existing schema variable. Identified by name; only the provided fields are changed.",
+		inputSchema: z.object({ variable: z.object({
+			name: z.string().describe("Variable name"),
+			type: variableTypesSchema.optional().describe("Variable type"),
+			value: z.string().optional().describe("Variable value"),
+			category: z.string().optional().describe("Grouping label shown in the builder UI")
+		}).describe("Variable fields to update") }),
+		outputSchema: z.object({
+			name: z.string().describe("Variable name"),
+			type: z.string().describe("Variable type"),
+			value: z.string().describe("Variable value"),
+			category: z.string().describe("Variable category")
+		}).describe("The updated variable")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { updateVariableTool as default };

package/dist/modules/mcp/tools/space/style/selectors/createStyleSelector.js

@@ -0,0 +1,37 @@
+import { getAllowedModes } from "../../../../helpers.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/space/style/selectors/createStyleSelector.ts
+var displayModes = z.enum([
+	"desktop",
+	"tablet",
+	"mobile"
+]);
+var tagTypes = z.enum([
+	"class",
+	"element",
+	"id"
+]);
+var createStyleSelectorTool = {
+	name: "create_style_selector",
+	adapterName: "createStyleSelector",
+	mcpDefinition: {
+		title: "Create Style Selector",
+		description: "Create a CSS selector entry in the space style for the specified display mode.\n\nDefines a new class, element, or ID selector with optional initial CSS rules. Elements reference selectors via their styleSelectors map.",
+		inputSchema: z.object({
+			displayMode: displayModes.describe("Responsive breakpoint this selector applies to"),
+			selector: z.string().describe("CSS selector string (e.g. \".hero-banner\", \"button\", \"#nav\")"),
+			type: tagTypes.describe("Selector kind: \"class\" for .className, \"element\" for HTML tag, \"id\" for #id"),
+			path: z.string().optional().describe("Internal scope path — omit in most cases"),
+			style: z.record(z.string(), z.record(z.string(), z.unknown())).optional().describe("Initial CSS rules keyed by sub-selector slot (e.g. { base: { backgroundColor: \"#3b82f6\" } })"),
+			params: z.record(z.string(), z.unknown()).optional().describe("Advanced adapter parameters — omit in most cases")
+		}),
+		outputSchema: z.object({
+			displayMode: z.string().describe("Display mode"),
+			selector: z.string().describe("CSS selector"),
+			type: z.string().describe("Selector type")
+		}).catchall(z.unknown()).describe("The created style selector")
+	},
+	definition: { allowedModes: getAllowedModes("write") }
+};
+//#endregion
+export { createStyleSelectorTool as default };