@cplace/test-mcp-server 0.1.7 → 0.1.9

package/dist/index.js

@@ -13,19 +13,19 @@ import { convertPagesToCsv } from "./csvUtils.js";
 dotenv.config();
 const config = {
     url: process.env.CPLACE_URL || '',
-    apiToken: process.env.API_TOKEN || ''
+    apiToken: process.env.API_TOKEN || '',
+    registerSystemInfoTool: process.env.REGISTER_SYSTEM_INFO_TOOL === 'true' || false,
 };
 const client = new CplaceApiClient(config);
-const REGISTER_SYSTEM_INFO_TOOL = false;
 const server = new McpServer({
     name: "cplace-mcp-server",
     version: "1.0.0"
 });
-if (REGISTER_SYSTEM_INFO_TOOL) {
-    server.registerTool("cplace_system_info", {
+if (config.registerSystemInfoTool) {
+    server.registerTool("cplace_get_system_info", {
         description: "Get system information about the MCP server - including current working directory, CPLACE_URL setting, and debug state",
         inputSchema: {},
-        annotations: { title: "System Information" }
+        annotations: { title: "Get System Information" }
     }, async () => {
         const systemInfo = {
             currentWorkingDirectory: process.cwd(),
@@ -66,12 +66,12 @@ server.registerTool("cplace_list_workspaces", {
         };
     }
 });
-server.registerTool("cplace_get_types_in_workspace", {
-    description: "Get a list of all types available in a certain workspace",
+server.registerTool("cplace_list_types", {
+    description: "List all types available in a workspace",
     inputSchema: {
         workspaceId: z.string().describe("The ID of the workspace to get types for")
     },
-    annotations: { title: "Get Types in Workspace" }
+    annotations: { title: "List Types" }
 }, async ({ workspaceId }) => {
     try {
         const workspaces = await client.makeApiRequest('json/workspaces');
@@ -115,6 +115,58 @@ server.registerTool("cplace_get_type_datamodel", {
         };
     }
 });
+server.registerTool("cplace_get_type_incoming_references", {
+    description: "Get comprehensive information about all incoming references to a specific type definition. Identifies all attributes from other types that can reference pages of the target type, including custom attributes and built-in attributes.",
+    inputSchema: {
+        workspaceId: z.string().describe("The ID of the workspace containing the target type definition"),
+        internalName: z.string().describe("The internal name of the target type definition")
+    },
+    annotations: { title: "Get Type Incoming References" }
+}, async ({ workspaceId, internalName }) => {
+    debugLogWithTag('TYPE_REFS', `Starting incoming references request for type: ${internalName} in workspace: ${workspaceId}`);
+    try {
+        const result = await client.makeApiRequest('json/type/incoming-references', 'GET', {
+            workspaceId,
+            internalName
+        });
+        debugLogWithTag('TYPE_REFS', `Retrieved ${result.count || 0} incoming references for type: ${internalName}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('TYPE_REFS', `Error retrieving incoming references: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error retrieving type incoming references: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_get_page_incoming_references", {
+    description: "Get comprehensive information about all incoming references to a specific page. Identifies all pages that reference the target page through specific attributes, providing detailed information about the referencing pages and the attributes used for the references.",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the target page"),
+        includeReferences: z.string().describe("JSON string specifying which references to include. Must be a JSON array containing objects with 'sourceType' and 'attributeName' properties, e.g. '[{\"sourceType\":\"cf.example.Project\",\"attributeName\":\"relatedTask\"}]'")
+    },
+    annotations: { title: "Get Page Incoming References" }
+}, async ({ pageUID, includeReferences }) => {
+    debugLogWithTag('PAGE_REFS', `Starting incoming references request for page: ${pageUID}`);
+    try {
+        const result = await client.makeApiRequest('json/page/incoming-references', 'GET', {
+            pageUID,
+            includeReferences
+        });
+        debugLogWithTag('PAGE_REFS', `Retrieved ${result.totalCount || 0} incoming references for page: ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('PAGE_REFS', `Error retrieving incoming references: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error retrieving page incoming references: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
 server.registerTool("cplace_get_page_by_id", {
     description: "Get comprehensive page information including relationships and metadata",
     inputSchema: {
@@ -123,7 +175,7 @@ server.registerTool("cplace_get_page_by_id", {
     annotations: { title: "Get Page by ID" }
 }, async ({ id }) => {
     try {
-        const result = await client.makeApiRequest('json/page', 'GET', { id });
+        const result = await client.makeApiRequest('json/page', 'GET', { pageUID: id });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -153,12 +205,12 @@ server.registerTool("cplace_get_person_by_id", {
         };
     }
 });
-server.registerTool("cplace_search_person", {
-    description: "Search a person by their name.",
+server.registerTool("cplace_get_person_by_name", {
+    description: "Get details about a person by searching for their name.",
     inputSchema: {
         name: z.string().describe("The name of the person or part of the name to search for"),
     },
-    annotations: { title: "Get Person by ID" }
+    annotations: { title: "Get Person by Name" }
 }, async ({ name }) => {
     try {
         const result = await client.makeApiRequest('json/person', 'GET', { name });
@@ -284,7 +336,8 @@ Empty/not empty checks:
                 offset: result.pagination?.offset || offset,
                 hasMore: result.pagination?.hasMore || false
             },
-            humanReadableRepresentation: result.summary
+            humanReadableRepresentation: result.summary,
+            cplaceJson: result.cplaceJson
         };
         return {
             content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
@@ -297,15 +350,15 @@ Empty/not empty checks:
         };
     }
 });
-server.registerTool("cplace_fulltext_search", {
-    description: "Make a fulltext search across all pages in cplace. Use this only if the user is not asking about specific types.",
+server.registerTool("cplace_search_pages_fulltext", {
+    description: "Make a fulltext search across all pages in cplace. Use this when searching for text content within pages.",
     inputSchema: {
         workspaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
-        fulltext: z.string().describe("The fulltext search query to filter pages by. The results will include pages that conatin this string in their name, attributes, or content."),
+        fulltext: z.string().describe("The fulltext search query to filter pages by. The results will include pages that contain this string in their name, attributes, or content."),
         limit: z.number().min(1).max(1000).default(50).describe("Maximum number of results to return (1-1000)"),
         offset: z.number().min(0).max(10000).default(0).describe("Number of results to skip for pagination, cannot be larger than 10000"),
     },
-    annotations: { title: "Search Pages" }
+    annotations: { title: "Search Pages by Fulltext" }
 }, async ({ workspaceId, fulltext, limit = 50, offset = 0, }) => {
     if (!fulltext) {
         return {
@@ -333,7 +386,8 @@ server.registerTool("cplace_fulltext_search", {
                 offset: result.pagination?.offset || offset,
                 hasMore: result.pagination?.hasMore || false
             },
-            summary: result.summary
+            summary: result.summary,
+            cplaceJson: result.cplaceJson
         };
         return {
             content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
@@ -345,15 +399,15 @@ server.registerTool("cplace_fulltext_search", {
         };
     }
 });
-server.registerTool("cplace_get_all_pages_of_type", {
-    description: "Get all pages of a specific type in a workspace in cplace. ONLY use this if you need to retrieve all pages of a type.",
+server.registerTool("cplace_list_pages_of_type", {
+    description: "List all pages of a specific type in a workspace in cplace. Use this to retrieve multiple pages of the same type.",
     inputSchema: {
         workspaceId: z.string().describe("The ID of the workspace to get pages from"),
         typeName: z.string().describe("The internal name of the type to retrieve pages for"),
         limit: z.number().min(1).max(1000).default(50).describe("Maximum number of results to return (1-1000)"),
         offset: z.number().min(0).max(10000).default(0).describe("Number of results to skip for pagination, cannot be larger than 10000"),
     },
-    annotations: { title: "Get All Pages of Type" }
+    annotations: { title: "List Pages of Type" }
 }, async ({ workspaceId, typeName, limit = 50, offset = 0, }) => {
     try {
         const cplaceFilter = {
@@ -448,14 +502,19 @@ server.registerTool("cplace_search_pages_csv", {
     }
 });
 server.registerTool("cplace_list_widget_definitions", {
-    description: "Get a list of all available widget definitions in the system with their basic metadata including names, descriptions, and apps",
-    inputSchema: {},
+    description: "Get a list of all available widget definitions in the system that support the specified embedding context, with their basic metadata including names, descriptions, and apps",
+    inputSchema: {
+        embeddingContext: z.enum(["AS_WIDGET", "INSIDE_RICHSTRING", "INSIDE_WIDGET"]).default("AS_WIDGET").describe(`Filter widgets by embedding context support:
+- AS_WIDGET (default): Widgets that support full widget embedding with frame and title
+- INSIDE_RICHSTRING: Widgets that can be embedded in rich text content without frame
+- INSIDE_WIDGET: Widgets that can be embedded inside other widgets without frame`)
+    },
     annotations: { title: "List Widget Definitions" }
-}, async () => {
-    debugLogWithTag('WIDGETS', 'Starting widget definitions list request');
+}, async ({ embeddingContext = "AS_WIDGET" }) => {
+    debugLogWithTag('WIDGETS', `Starting widget definitions list request with embeddingContext: ${embeddingContext}`);
     try {
-        const result = await client.makeApiRequest('json/widget-definitions');
-        debugLogWithTag('WIDGETS', `Retrieved widget definitions`);
+        const result = await client.makeApiRequest('json/widget-definitions', 'GET', { embeddingContext });
+        debugLogWithTag('WIDGETS', `Retrieved widget definitions for context: ${embeddingContext}`);
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -490,13 +549,13 @@ server.registerTool("cplace_get_widget_definition", {
 server.registerTool("cplace_get_page_layout_overview", {
     description: "Get the high-level layout structure of a page including rows, columns, and widget summaries. Provides an overview of the page layout grid without detailed widget configurations.",
     inputSchema: {
-        id: z.string().describe("The unique identifier (UID) of the page to get layout for, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
+        pageUID: z.string().describe("The unique identifier (UID) of the page to get layout for, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
     },
     annotations: { title: "Get Page Layout Overview" }
-}, async ({ id }) => {
-    debugLogWithTag('LAYOUT', `Starting page layout overview request for: ${id}`);
+}, async ({ pageUID }) => {
+    debugLogWithTag('LAYOUT', `Starting page layout overview request for: ${pageUID}`);
     try {
-        const result = await client.makeApiRequest('json/pageLayout', 'GET', { id });
+        const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
         const overview = {
             rows: result.rows?.map((row, rowIndex) => ({
                 rowIndex,
@@ -511,28 +570,28 @@ server.registerTool("cplace_get_page_layout_overview", {
                 })) || []
             })) || []
         };
-        debugLogWithTag('LAYOUT', `Retrieved layout overview for: ${id}`);
+        debugLogWithTag('LAYOUT', `Retrieved page layout overview for: ${pageUID}`);
         return {
             content: [{ type: "text", text: JSON.stringify(overview, null, 2) }]
         };
     }
     catch (error) {
         return {
-            content: [{ type: "text", text: `Error retrieving page layout overview for ${id}: ${error instanceof Error ? error.message : String(error)}` }]
+            content: [{ type: "text", text: `Error retrieving page layout overview for ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
         };
     }
 });
 server.registerTool("cplace_get_widget_details", {
     description: "Get detailed configuration for a specific widget within a page layout. Use this after cplace_get_page_layout_overview to examine specific widget configurations.",
     inputSchema: {
-        pageId: z.string().describe("The unique identifier (UID) of the page containing the widget"),
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
         widgetId: z.string().describe("The unique widget identifier from the layout (e.g., 'id_123', 'id_456')")
     },
     annotations: { title: "Get Widget Details" }
-}, async ({ pageId, widgetId }) => {
-    debugLogWithTag('LAYOUT', `Starting widget details request for widget ${widgetId} in page ${pageId}`);
+}, async ({ pageUID, widgetId }) => {
+    debugLogWithTag('LAYOUT', `Starting widget details request for widget ${widgetId} in page ${pageUID}`);
     try {
-        const result = await client.makeApiRequest('json/pageLayout', 'GET', { id: pageId });
+        const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
         let foundWidget = null;
         const findWidget = (rows) => {
             for (const row of rows || []) {
@@ -554,17 +613,17 @@ server.registerTool("cplace_get_widget_details", {
         foundWidget = findWidget(result.rows);
         if (!foundWidget) {
             return {
-                content: [{ type: "text", text: `Widget with ID ${widgetId} not found in page ${pageId}` }]
+                content: [{ type: "text", text: `Widget with ID ${widgetId} not found in page ${pageUID}` }]
             };
         }
-        debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId}`);
+        debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId} in page`);
         return {
             content: [{ type: "text", text: JSON.stringify(foundWidget, null, 2) }]
         };
     }
     catch (error) {
         return {
-            content: [{ type: "text", text: `Error retrieving widget details for ${widgetId} in page ${pageId}: ${error instanceof Error ? error.message : String(error)}` }]
+            content: [{ type: "text", text: `Error retrieving widget details for ${widgetId} in page ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
         };
     }
 });
@@ -587,6 +646,504 @@ server.registerTool("cplace_get_current_user", {
         };
     }
 });
+server.registerTool("cplace_create_page", {
+    description: "Create a new page with specified attributes and content using the POST /page/create endpoint",
+    inputSchema: {
+        workspaceId: z.string().describe("The ID of the workspace/space to create the page in (e.g., 'workspace/abc123')"),
+        typeInternalName: z.string().describe("The internal name of the page type (e.g., 'cf.example.myType')"),
+        name: z.string().describe("The name of the new page"),
+        parentUID: z.string().optional().describe("The UID of the parent page for hierarchy (optional)"),
+        content: z.string().optional().describe("Wiki markup content for the page (optional)"),
+        attributes: z.record(z.any()).optional().describe(`Custom attribute values as key-value pairs. Supports:
+- String values: "text"
+- Numeric values: 42 or 3.14  
+- Boolean values: true/false
+- Date values: "2024-01-15" or "2024-01-15T10:30:00"
+- Array values: ["value1", "value2"] for multi-valued attributes
+- Reference values: "page/ref123" for page references
+- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
+- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
+
+The system automatically detects attribute types from the page type definition and handles:
+- Type-aware processing based on actual attribute definitions
+- Proper multiplicity validation (single vs multi-valued)
+- Automatic type conversion and validation
+- Enhanced error messages with attribute-specific details`)
+    },
+    annotations: { title: "Create Page" }
+}, async ({ workspaceId, typeInternalName, name, parentUID, content, attributes }) => {
+    debugLogWithTag('CREATE_PAGE', `Starting page creation: ${name} of type ${typeInternalName} in workspace ${workspaceId}`);
+    try {
+        const requestBody = {
+            workspaceId,
+            typeInternalName,
+            name
+        };
+        if (parentUID) {
+            requestBody.parentUID = parentUID;
+            debugLogWithTag('CREATE_PAGE', `Including parentUID: ${parentUID}`);
+        }
+        if (content) {
+            requestBody.content = content;
+            debugLogWithTag('CREATE_PAGE', `Including content (${content.length} chars)`);
+        }
+        if (attributes && Object.keys(attributes).length > 0) {
+            requestBody.attributes = attributes;
+            debugLogWithTag('CREATE_PAGE', `Including attributes: ${JSON.stringify(Object.keys(attributes))}`);
+        }
+        debugLogWithTag('CREATE_PAGE', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/page/create', 'POST', undefined, requestBody);
+        debugLogWithTag('CREATE_PAGE', `Successfully created page: ${name}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('CREATE_PAGE', `Error creating page: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error creating page: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_update_page", {
+    description: "Update an existing page's attributes, content, or structure using the PATCH /page/{pageId} endpoint",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page to update"),
+        name: z.string().optional().describe("New name for the page (optional)"),
+        content: z.string().optional().describe("New wiki markup content (optional). Use empty string to remove content."),
+        parentUID: z.string().optional().describe("New parent page UID (optional - for moving pages). Use empty string to remove parent."),
+        attributes: z.record(z.any()).optional().describe(`Custom attributes to update as key-value pairs. Supports:
+- String values: "text"
+- Numeric values: 42 or 3.14
+- Boolean values: true/false  
+- Date values: "2024-01-15" or "2024-01-15T10:30:00"
+- Array values: ["value1", "value2"] for multi-valued attributes
+- Reference values: "page/ref123" for page references
+- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
+- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
+- Null values: null (removes the attribute value)
+- Empty arrays: [] (removes all values for multi-valued attributes)
+- New attributes: will be added to the page
+
+The system automatically detects attribute types from the page type definition and handles:
+- Type-aware processing based on actual attribute definitions
+- Proper multiplicity validation (single vs multi-valued)
+- Automatic type conversion and validation
+- Enhanced error messages with attribute-specific details`)
+    },
+    annotations: { title: "Update Page" }
+}, async ({ pageUID, name, content, parentUID, attributes }) => {
+    debugLogWithTag('UPDATE_PAGE', `Starting page update for: ${pageUID}`);
+    try {
+        const requestBody = {
+            pageUID
+        };
+        if (name !== undefined) {
+            requestBody.name = name;
+        }
+        if (content !== undefined) {
+            requestBody.content = content;
+        }
+        if (parentUID !== undefined) {
+            requestBody.parentUID = parentUID;
+        }
+        if (attributes && Object.keys(attributes).length > 0) {
+            requestBody.attributes = attributes;
+        }
+        if (Object.keys(requestBody).length === 1) {
+            return {
+                content: [{ type: "text", text: "No updates specified. At least one of name, content, parentId, or attributes must be provided." }]
+            };
+        }
+        const result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
+        debugLogWithTag('UPDATE_PAGE', `Successfully updated page: ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('UPDATE_PAGE', `Error updating page: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error updating page: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_update_page_attributes", {
+    description: "Update page attributes (no content or structural changes) using the PATCH /page/{pageId} endpoint",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page to update"),
+        attributes: z.record(z.any()).describe(`Attribute updates as key-value pairs. Supports all the same data types as the full update tool:
+- String values: "text"
+- Numeric values: 42 or 3.14
+- Boolean values: true/false  
+- Date values: "2024-01-15" or "2024-01-15T10:30:00"
+- Array values: ["value1", "value2"] for multi-valued attributes
+- Reference values: "page/ref123" for page references
+- Localized string values: {"en": "English text", "de": "German text", "fr": "French text"}
+- Multi-valued localized strings: [{"en": "Text 1", "de": "Text 1"}, {"en": "Text 2", "de": "Text 2"}]
+- Null values: null (removes the attribute value)
+- Empty arrays: [] (removes all values for multi-valued attributes)
+- New attributes: will be added to the page
+
+The system automatically detects attribute types from the page type definition and handles:
+- Type-aware processing based on actual attribute definitions
+- Proper multiplicity validation (single vs multi-valued)
+- Automatic type conversion and validation
+- Enhanced error messages with attribute-specific details`)
+    },
+    annotations: { title: "Update Page Attributes" }
+}, async ({ pageUID, attributes }) => {
+    debugLogWithTag('UPDATE_PAGE_ATTRS', `Starting attribute-only update for: ${pageUID}`);
+    try {
+        if (!attributes || Object.keys(attributes).length === 0) {
+            return {
+                content: [{ type: "text", text: "No attributes specified for update. The attributes parameter must contain at least one attribute." }]
+            };
+        }
+        const requestBody = {
+            pageUID,
+            attributes: attributes
+        };
+        const result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
+        debugLogWithTag('UPDATE_PAGE_ATTRS', `Successfully updated attributes for page: ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('UPDATE_PAGE_ATTRS', `Error updating page attributes: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error updating page attributes: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_add_widget_to_layout", {
+    description: "Add a new widget to a page layout at a specific position. Supports both page-level layouts (default) and embedded layouts within container widgets like AttributesGroup.",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page to add the widget to"),
+        widgetType: z.string().describe("The widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki', 'cf.platform.singleAttribute')"),
+        configuration: z.record(z.any()).optional().describe(`Widget-specific configuration object as key-value pairs. IMPORTANT: Check the widget definition schema first to understand required data types:
+- localizedString attributes: use {"en": "English text", "de": "German text"} format
+- boolean attributes: use true/false
+- number attributes: use numeric values
+- string attributes: use simple strings
+
+RECOMMENDED WORKFLOW: 
+1. Use cplace_get_widget_definition() first to understand the configuration schema
+2. Match your configuration values to the constraint types defined in the schema
+3. Use appropriate data formats for each attribute type
+
+Examples: {'title': {'en': 'My Widget', 'de': 'Mein Widget'}, 'showHeader': true, 'height': 600}
+For embedded attribute widgets: {'cf.platform.quotedAttributeName': "'cf.cplace.myAttribute'", 'cf.platform.withLabel': true}`),
+        position: z.object({
+            rowIndex: z.number().min(0).describe("Row index in the layout (0-based)"),
+            columnIndex: z.number().min(0).describe("Column index within the row (0-based)"),
+            widgetIndex: z.number().min(0).describe("Widget index within the column (0-based)")
+        }).describe("Grid position where the widget should be added"),
+        layoutContext: z.enum(["page", "widget"]).default("page").describe("Layout context: 'page' for page-level layout (default), 'widget' for embedded layout within a container widget"),
+        containerWidgetId: z.string().optional().describe("Required when layoutContext is 'widget'. The unique identifier of the container widget (e.g., AttributesGroup widget) that contains the embedded layout to modify"),
+        layoutAttributeName: z.string().optional().describe("Optional layout attribute name for embedded layouts. If not provided, it will be auto-detected based on the container widget type")
+    },
+    annotations: { title: "Add Widget to Layout" }
+}, async ({ pageUID, widgetType, configuration, position, layoutContext = "page", containerWidgetId, layoutAttributeName }) => {
+    debugLogWithTag('LAYOUT_MODIFY', `Starting add widget operation: ${widgetType} to ${layoutContext === "widget" ? "embedded layout in container " + containerWidgetId : "page layout"} ${pageUID} at position ${JSON.stringify(position)}`);
+    try {
+        if (layoutContext === "widget") {
+            if (!containerWidgetId) {
+                return {
+                    content: [{ type: "text", text: "containerWidgetId is required when layoutContext is 'widget'" }]
+                };
+            }
+            debugLogWithTag('LAYOUT_MODIFY', `Adding to embedded layout in container widget: ${containerWidgetId}`);
+        }
+        const operation = {
+            type: "ADD",
+            widgetType,
+            position: {
+                rowIndex: position.rowIndex,
+                columnIndex: position.columnIndex,
+                widgetIndex: position.widgetIndex
+            }
+        };
+        if (configuration && Object.keys(configuration).length > 0) {
+            operation.configuration = configuration;
+            debugLogWithTag('LAYOUT_MODIFY', `Including configuration: ${JSON.stringify(Object.keys(configuration))}`);
+        }
+        const requestBody = {
+            pageUID,
+            layoutContext,
+            operation
+        };
+        if (layoutContext === "widget") {
+            requestBody.containerWidgetId = containerWidgetId;
+            if (layoutAttributeName) {
+                requestBody.layoutAttributeName = layoutAttributeName;
+            }
+        }
+        debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('LAYOUT_MODIFY', `Successfully added widget ${widgetType} to page ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('LAYOUT_MODIFY', `Error adding widget: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error adding widget to layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_remove_widget_from_layout", {
+    description: "Remove an existing widget from a page layout",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
+        widgetId: z.string().describe("The unique identifier of the widget to remove")
+    },
+    annotations: { title: "Remove Widget from Layout" }
+}, async ({ pageUID, widgetId }) => {
+    debugLogWithTag('LAYOUT_MODIFY', `Starting remove widget operation: ${widgetId} from page ${pageUID}`);
+    try {
+        const requestBody = {
+            pageUID,
+            operation: {
+                type: "REMOVE",
+                widgetId
+            }
+        };
+        debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('LAYOUT_MODIFY', `Successfully removed widget ${widgetId} from page ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('LAYOUT_MODIFY', `Error removing widget: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error removing widget from layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_update_widget_in_layout", {
+    description: "Modify widget configuration or display properties",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
+        widgetId: z.string().describe("The unique identifier of the widget to update"),
+        newConfiguration: z.record(z.any()).optional().describe(`Updated widget configuration as key-value pairs (optional). IMPORTANT: Check the widget definition schema first to understand required data types:
+- localizedString attributes: use {"en": "English text", "de": "German text"} format
+- boolean attributes: use true/false
+- number attributes: use numeric values
+- string attributes: use simple strings
+
+RECOMMENDED WORKFLOW: 
+1. Use cplace_get_widget_definition() first to understand the configuration schema
+2. Match your configuration values to the constraint types defined in the schema
+3. Use appropriate data formats for each attribute type
+
+Examples: {'title': {'en': 'My Widget', 'de': 'Mein Widget'}, 'showHeader': true, 'height': 600}`),
+        collapsed: z.boolean().optional().describe("Widget collapse state (optional)")
+    },
+    annotations: { title: "Update Widget in Layout" }
+}, async ({ pageUID, widgetId, newConfiguration, collapsed }) => {
+    debugLogWithTag('LAYOUT_MODIFY', `Starting update widget operation: ${widgetId} in page ${pageUID}`);
+    try {
+        const operation = {
+            type: "UPDATE",
+            widgetId
+        };
+        if (newConfiguration && Object.keys(newConfiguration).length > 0) {
+            operation.newConfiguration = newConfiguration;
+            debugLogWithTag('LAYOUT_MODIFY', `Including new configuration: ${JSON.stringify(Object.keys(newConfiguration))}`);
+        }
+        if (collapsed !== undefined) {
+            operation.collapsed = collapsed;
+            debugLogWithTag('LAYOUT_MODIFY', `Setting collapsed state to: ${collapsed}`);
+        }
+        if (!operation.newConfiguration && operation.collapsed === undefined) {
+            return {
+                content: [{ type: "text", text: "No updates specified. At least one of newConfiguration or collapsed must be provided." }]
+            };
+        }
+        const requestBody = {
+            pageUID,
+            operation
+        };
+        debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('LAYOUT_MODIFY', `Successfully updated widget ${widgetId} in page ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('LAYOUT_MODIFY', `Error updating widget: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error updating widget in layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_move_widget_in_layout", {
+    description: "Relocate a widget to a different position in the layout",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the widget"),
+        widgetId: z.string().describe("The unique identifier of the widget to move"),
+        newPosition: z.object({
+            rowIndex: z.number().min(0).describe("Target row index in the layout (0-based)"),
+            columnIndex: z.number().min(0).describe("Target column index within the row (0-based)"),
+            widgetIndex: z.number().min(0).describe("Target widget index within the column (0-based)")
+        }).describe("Target grid position for the widget")
+    },
+    annotations: { title: "Move Widget in Layout" }
+}, async ({ pageUID, widgetId, newPosition }) => {
+    debugLogWithTag('LAYOUT_MODIFY', `Starting move widget operation: ${widgetId} in page ${pageUID} to position ${JSON.stringify(newPosition)}`);
+    try {
+        const requestBody = {
+            pageUID,
+            operation: {
+                type: "MOVE",
+                widgetId,
+                newPosition: {
+                    rowIndex: newPosition.rowIndex,
+                    columnIndex: newPosition.columnIndex,
+                    widgetIndex: newPosition.widgetIndex
+                }
+            }
+        };
+        debugLogWithTag('LAYOUT_MODIFY', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/pageLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('LAYOUT_MODIFY', `Successfully moved widget ${widgetId} in page ${pageUID}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('LAYOUT_MODIFY', `Error moving widget: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error moving widget in layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_get_embedded_layout", {
+    description: "Get the widget layout structure of an embedded widget within a container widget on a specific page. This endpoint accesses nested widget layouts embedded within other widgets, such as AttributesGroup widgets.",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
+        containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout"),
+        layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure")
+    },
+    annotations: { title: "Get Embedded Layout" }
+}, async ({ pageUID, containerWidgetId, layoutAttributeName }) => {
+    debugLogWithTag('EMBEDDED_LAYOUT', `Starting embedded widget layout request for container ${containerWidgetId} in page ${pageUID}`);
+    try {
+        const result = await client.makeApiRequest('json/embeddedWidgetLayout', 'GET', {
+            pageUID,
+            containerWidgetId,
+            layoutAttributeName
+        });
+        debugLogWithTag('EMBEDDED_LAYOUT', `Retrieved embedded widget layout for container: ${containerWidgetId}`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error retrieving embedded widget layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_add_widget_to_embedded_layout", {
+    description: "Add a new widget to an embedded layout within a container widget. This enables adding widgets to nested layouts like those within AttributesGroup widgets.",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
+        containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout to modify"),
+        layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure"),
+        widgetType: z.string().describe("Widget type identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')"),
+        position: z.object({
+            rowIndex: z.number().min(0).describe("Row index in the embedded layout (0-based)"),
+            columnIndex: z.number().min(0).describe("Column index within the row (0-based)"),
+            widgetIndex: z.number().min(0).describe("Widget index within the column (0-based)")
+        }).describe("Position where the widget should be added in the embedded layout"),
+        configuration: z.record(z.any()).optional().describe(`Widget configuration as key-value pairs. IMPORTANT: Check the widget definition schema first to understand required data types:
+- localizedString attributes: use {"en": "English text", "de": "German text"} format
+- boolean attributes: use true/false
+- number attributes: use numeric values
+- string attributes: use simple strings
+
+RECOMMENDED WORKFLOW: 
+1. Use cplace_get_widget_definition() first to understand the configuration schema
+2. Match your configuration values to the constraint types defined in the schema
+3. Use appropriate data formats for each attribute type
+
+Examples: {'title': {'en': 'Embedded Widget', 'de': 'Eingebettetes Widget'}, 'showHeader': true}`)
+    },
+    annotations: { title: "Add Widget to Embedded Layout" }
+}, async ({ pageUID, containerWidgetId, layoutAttributeName, widgetType, position, configuration }) => {
+    debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Starting add widget to embedded layout: ${widgetType} to container ${containerWidgetId} in page ${pageUID}`);
+    try {
+        const operation = {
+            type: "ADD",
+            widgetType,
+            position
+        };
+        if (configuration && Object.keys(configuration).length > 0) {
+            operation.configuration = configuration;
+            debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Including configuration: ${JSON.stringify(Object.keys(configuration))}`);
+        }
+        const requestBody = {
+            pageUID,
+            containerWidgetId,
+            layoutAttributeName,
+            operation
+        };
+        debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/embeddedWidgetLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Successfully added widget ${widgetType} to embedded layout`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('EMBEDDED_LAYOUT_ADD', `Error adding widget to embedded layout: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error adding widget to embedded layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+server.registerTool("cplace_remove_widget_from_embedded_layout", {
+    description: "Remove an existing widget from an embedded layout within a container widget. This enables removing widgets from nested layouts like those within AttributesGroup widgets.",
+    inputSchema: {
+        pageUID: z.string().describe("The unique identifier (UID) of the page containing the container widget"),
+        containerWidgetId: z.string().describe("The ID of the container widget that contains the embedded layout to modify"),
+        layoutAttributeName: z.string().describe("The name of the attribute that defines the embedded layout structure"),
+        widgetId: z.string().describe("The ID of the existing widget to remove from the embedded layout")
+    },
+    annotations: { title: "Remove Widget from Embedded Layout" }
+}, async ({ pageUID, containerWidgetId, layoutAttributeName, widgetId }) => {
+    debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Starting remove widget from embedded layout: ${widgetId} from container ${containerWidgetId} in page ${pageUID}`);
+    try {
+        const requestBody = {
+            pageUID,
+            containerWidgetId,
+            layoutAttributeName,
+            operation: {
+                type: "REMOVE",
+                widgetId
+            }
+        };
+        debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Request body: ${JSON.stringify(requestBody, null, 2)}`);
+        const result = await client.makeApiRequest('json/embeddedWidgetLayout', 'PATCH', undefined, requestBody);
+        debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Successfully removed widget ${widgetId} from embedded layout`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('EMBEDDED_LAYOUT_REMOVE', `Error removing widget from embedded layout: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error removing widget from embedded layout: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);