@cplace/test-mcp-server 0.1.6 → 0.1.8

package/dist/index.js

@@ -7,21 +7,45 @@ import { CplaceApiClient } from './api.js';
 import SearchFilterSchema from "./searchSchema.js";
 import { convertSearchFilterToCplaceFormat } from "./searchConversion.js";
 import { filterSearchResult } from "./utils.js";
+import { debugLogWithTag } from "./logger.js";
+import { DEBUG_LOGGING } from "./logger.js";
+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,
+    registerLayoutTools: process.env.REGISTER_LAYOUT_TOOLS === 'true' || false,
 };
 const client = new CplaceApiClient(config);
 const server = new McpServer({
     name: "cplace-mcp-server",
     version: "1.0.0"
 });
+if (config.registerSystemInfoTool) {
+    server.registerTool("cplace_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" }
+    }, async () => {
+        const systemInfo = {
+            currentWorkingDirectory: process.cwd(),
+            cplaceUrl: config.url || 'Not set',
+            debugLogging: DEBUG_LOGGING,
+            nodeVersion: process.version,
+            platform: process.platform
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(systemInfo, null, 2) }]
+        };
+    });
+}
 server.registerTool("cplace_list_workspaces", {
     description: "Get a list of all workspaces with essential properties (id, name, displayName, totalPages, isFavorite, installed apps)",
     inputSchema: {},
     annotations: { title: "List Workspaces" }
 }, async () => {
+    debugLogWithTag('WORKSPACES', 'Starting workspace list request');
     try {
         const workspaces = await client.makeApiRequest('json/workspaces');
         const filteredWorkspaces = workspaces.map((workspace) => ({
@@ -32,6 +56,7 @@ server.registerTool("cplace_list_workspaces", {
             isFavorite: workspace.isFavorite,
             installedApps: workspace.apps?.installed?.map(app => app.name) || []
         }));
+        debugLogWithTag('WORKSPACES', `Retrieved ${filteredWorkspaces.length} workspaces`);
         return {
             content: [{ type: "text", text: JSON.stringify(filteredWorkspaces, null, 2) }]
         };
@@ -99,7 +124,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) }]
         };
@@ -151,25 +176,78 @@ server.registerTool("cplace_search_person", {
 server.registerTool("cplace_search_pages", {
     description: "Search pages of a type in cplace.",
     inputSchema: {
-        spaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
-        internalTypeName: z.string().describe("The internal name of the type to filter by"),
-        search_filter: SearchFilterSchema.describe('Search Filters'),
+        workspaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
+        internalTypeName: z.string().describe(`The internal name of the type to filter by. Examples:
+- "cf.cplace.solution.safe.feature" for Feature pages
+- "cf.cplace.solution.safe.epic" for Epic pages  
+- "cf.cplace.solution.safe.story" for Story pages
+- "cf.projectNavigator.project" for Project pages
+- "cf.cplace.solution.safe.portfolio" for Portfolio pages
+Use cplace_get_types_in_workspace to discover available types in a workspace.`),
+        search_filter: SearchFilterSchema.describe(`Search Filters using cplace filter format. Examples:
+
+Basic string filter:
+[{"attribute": "cf.cplace.workflow", "string": {"equals": "approved"}}]
+
+Multiple conditions:
+[
+  {"name": {"equals": "Project Alpha"}},
+  {"attribute": "cf.cplace.location", "reference": {"equals": "page/abc123"}}
+]
+
+Date range filter:
+[
+  {"attribute": "cf.cplace.projectStart", "date": {"on_or_after": "2023-01-01"}},
+  {"attribute": "cf.cplace.projectFinish", "date": {"on_or_before": "2024-12-31"}}
+]
+
+Number comparison:
+[{"attribute": "cf.cplace.estimatedCost", "number": {"greater_than": 1000}}]
+
+Logical OR operator:
+[{
+  "or": [
+    {"attribute": "cf.cplace.managementPriority", "string": {"equals": "Focus"}},
+    {"attribute": "cf.cplace.managementPriority", "string": {"equals": "Accelerate"}}
+  ]
+}]
+
+Complex AND/OR combination:
+[{
+  "and": [
+    {"attribute": "cf.cplace.workflow", "string": {"equals": "inProgress"}},
+    {
+      "or": [
+        {"attribute": "cf.cplace.priority", "string": {"equals": "High"}},
+        {"attribute": "cf.cplace.priority", "string": {"equals": "Critical"}}
+      ]
+    }
+  ]
+}]
+
+Boolean filter:
+[{"attribute": "cf.cplace.isActive", "boolean": {"equals": true}}]
+
+Empty/not empty checks:
+[{"attribute": "cf.cplace.description", "string": {"is_not_empty": true}}]`),
         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"),
+        responseFormat: z.enum(["minimal", "count"]).optional().describe(`Response format options:
+- Default (not specified): Complete page data, respects 'attributes' parameter
+- "minimal": Only core fields (id, name, url, type, workspace)
+- "count": Only return the total count of matching pages`),
+        attributes: z.array(z.string()).optional().describe("Specific attribute names to include in response. If not provided, all attributes are included. Examples: ['cf.cplace.workflow', 'cf.cplace.priority']"),
     },
     annotations: { title: "Search Pages" }
-}, async ({ spaceId, internalTypeName, search_filter, limit = 50, offset = 0, }) => {
-    if (!search_filter) {
-        return {
-            content: [{ type: "text", text: "search_filter is required" }]
-        };
-    }
+}, async ({ workspaceId, internalTypeName, search_filter, limit = 50, offset = 0, responseFormat, attributes, }) => {
+    debugLogWithTag('SEARCH', `Starting search with params: workspaceId=${workspaceId || 'none'}, type=${internalTypeName}, filter=${JSON.stringify(search_filter)}, limit=${limit}, offset=${offset}`);
     try {
         const cplaceFilter = convertSearchFilterToCplaceFormat(search_filter);
-        if (spaceId) {
+        debugLogWithTag('SEARCH', `Converted filter: ${JSON.stringify(cplaceFilter)}`);
+        if (workspaceId) {
             cplaceFilter.filters.unshift({
                 type: "Workspace",
-                workspaceIds: [spaceId]
+                workspaceIds: [workspaceId]
             });
         }
         if (internalTypeName) {
@@ -178,23 +256,43 @@ server.registerTool("cplace_search_pages", {
                 types: [internalTypeName]
             });
         }
+        debugLogWithTag('SEARCH', `Final cplace filter: ${JSON.stringify(cplaceFilter)}`);
         const result = await client.makeApiRequest('json/search', 'GET', {
             filter: JSON.stringify(cplaceFilter),
             limit,
             offset
         });
+        if (responseFormat === "count") {
+            const countResult = {
+                count: result.pagination?.total || 0
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(countResult, null, 2) }]
+            };
+        }
         const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: false,
-            includeAttributes: true,
+            minimal: responseFormat === "minimal",
+            includeAttributes: responseFormat !== "minimal",
             includeMetadata: false,
+            attributeFields: attributes,
             truncateLargeValues: true
         })) : [];
-        const filteredResult = { ...result, results: filteredResults };
+        const filteredResult = {
+            results: filteredResults,
+            pagination: {
+                total: result.pagination?.total || 0,
+                limit: result.pagination?.limit || limit,
+                offset: result.pagination?.offset || offset,
+                hasMore: result.pagination?.hasMore || false
+            },
+            humanReadableRepresentation: result.summary
+        };
         return {
             content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
         };
     }
     catch (error) {
+        debugLogWithTag('SEARCH', `Error during search: ${error instanceof Error ? error.message : String(error)}`);
         return {
             content: [{ type: "text", text: `Error converting or executing search: ${error instanceof Error ? error.message : String(error)}` }]
         };
@@ -203,13 +301,13 @@ server.registerTool("cplace_search_pages", {
 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.",
     inputSchema: {
-        spaceId: z.string().optional().describe("The ID of the workspace to search in. If not provided, searches across all accessible workspaces."),
+        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."),
         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" }
-}, async ({ spaceId, fulltext, limit = 50, offset = 0, }) => {
+}, async ({ workspaceId, fulltext, limit = 50, offset = 0, }) => {
     if (!fulltext) {
         return {
             content: [{ type: "text", text: "fulltext is required" }]
@@ -217,7 +315,7 @@ server.registerTool("cplace_fulltext_search", {
     }
     try {
         const result = await client.makeApiRequest('json/fulltext-search', 'GET', {
-            spaceId,
+            spaceId: workspaceId,
             fulltext: `"${fulltext}"`,
             limit,
             offset
@@ -228,7 +326,16 @@ server.registerTool("cplace_fulltext_search", {
             includeMetadata: false,
             truncateLargeValues: true
         })) : [];
-        const filteredResult = { ...result, results: filteredResults };
+        const filteredResult = {
+            results: filteredResults,
+            pagination: {
+                total: result.pagination?.total || 0,
+                limit: result.pagination?.limit || limit,
+                offset: result.pagination?.offset || offset,
+                hasMore: result.pagination?.hasMore || false
+            },
+            summary: result.summary
+        };
         return {
             content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
         };
@@ -242,19 +349,19 @@ 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.",
     inputSchema: {
-        spaceId: z.string().describe("The ID of the workspace to get pages from"),
+        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" }
-}, async ({ spaceId, typeName, limit = 50, offset = 0, }) => {
+}, async ({ workspaceId, typeName, limit = 50, offset = 0, }) => {
     try {
         const cplaceFilter = {
             filters: [
                 {
                     type: "Workspace",
-                    workspaceIds: [spaceId]
+                    workspaceIds: [workspaceId]
                 },
                 {
                     type: "Type",
@@ -273,7 +380,16 @@ server.registerTool("cplace_get_all_pages_of_type", {
             includeMetadata: false,
             truncateLargeValues: true
         })) : [];
-        const filteredResult = { ...result, results: filteredResults };
+        const filteredResult = {
+            results: filteredResults,
+            pagination: {
+                total: result.pagination?.total || 0,
+                limit: result.pagination?.limit || limit,
+                offset: result.pagination?.offset || offset,
+                hasMore: result.pagination?.hasMore || false
+            },
+            summary: result.summary
+        };
         return {
             content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
         };
@@ -284,6 +400,569 @@ server.registerTool("cplace_get_all_pages_of_type", {
         };
     }
 });
+server.registerTool("cplace_search_pages_csv", {
+    description: "Same as cplace_search_pages but returns results in CSV format instead of JSON. Only use this tool after first calling cplace_search_pages to establish and validate the search parameters. The CSV result should always be stored as an artifact.",
+    inputSchema: {
+        workspaceId: z.string().optional().describe("Same as cplace_search_pages"),
+        internalTypeName: z.string().describe("Same as cplace_search_pages"),
+        search_filter: SearchFilterSchema.describe("Same as cplace_search_pages"),
+        limit: z.number().min(1).max(1000).default(50).describe("Same as cplace_search_pages"),
+        offset: z.number().min(0).max(10000).default(0).describe("Same as cplace_search_pages"),
+        attributes: z.array(z.string()).optional().describe("Same as cplace_search_pages"),
+    },
+    annotations: { title: "Search Pages (CSV Export)" }
+}, async ({ workspaceId, internalTypeName, search_filter, limit = 50, offset = 0, attributes, }) => {
+    debugLogWithTag('CSV_SEARCH', `Starting CSV search with params: workspaceId=${workspaceId || 'none'}, type=${internalTypeName}, filter=${JSON.stringify(search_filter)}, limit=${limit}, offset=${offset}`);
+    try {
+        const cplaceFilter = convertSearchFilterToCplaceFormat(search_filter);
+        debugLogWithTag('CSV_SEARCH', `Converted filter: ${JSON.stringify(cplaceFilter)}`);
+        if (workspaceId) {
+            cplaceFilter.filters.unshift({
+                type: "Workspace",
+                workspaceIds: [workspaceId]
+            });
+        }
+        if (internalTypeName) {
+            cplaceFilter.filters.unshift({
+                type: "Type",
+                types: [internalTypeName]
+            });
+        }
+        debugLogWithTag('CSV_SEARCH', `Final cplace filter: ${JSON.stringify(cplaceFilter)}`);
+        const result = await client.makeApiRequest('json/search', 'GET', {
+            filter: JSON.stringify(cplaceFilter),
+            limit,
+            offset
+        });
+        const searchResults = result.results || [];
+        debugLogWithTag('CSV_SEARCH', `Retrieved ${searchResults.length} results for CSV conversion`);
+        const csvContent = await convertPagesToCsv(searchResults, client, attributes);
+        return {
+            content: [{ type: "text", text: csvContent }]
+        };
+    }
+    catch (error) {
+        debugLogWithTag('CSV_SEARCH', `Error during CSV search: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            content: [{ type: "text", text: `Error converting or executing CSV search: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+if (config.registerLayoutTools) {
+    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: {},
+        annotations: { title: "List Widget Definitions" }
+    }, async () => {
+        debugLogWithTag('WIDGETS', 'Starting widget definitions list request');
+        try {
+            const result = await client.makeApiRequest('json/widget-definitions');
+            debugLogWithTag('WIDGETS', `Retrieved widget definitions`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error retrieving widget definitions: ${error instanceof Error ? error.message : String(error)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    server.registerTool("cplace_get_widget_definition", {
+        description: "Get detailed information about a specific widget definition including its complete configuration schema with all attributes, constraints, and metadata",
+        inputSchema: {
+            widgetKind: z.string().describe("The widget kind identifier (e.g., 'cf.cplace.platform.table', 'cf.platform.wiki')")
+        },
+        annotations: { title: "Get Widget Definition Details" }
+    }, async ({ widgetKind }) => {
+        debugLogWithTag('WIDGETS', `Starting widget definition request for: ${widgetKind}`);
+        try {
+            const result = await client.makeApiRequest('json/widget-definition', 'GET', { widgetKind });
+            debugLogWithTag('WIDGETS', `Retrieved widget definition for: ${widgetKind}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error retrieving widget definition for ${widgetKind}: ${error instanceof Error ? error.message : String(error)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    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: {
+            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 ({ pageUID }) => {
+        debugLogWithTag('LAYOUT', `Starting page layout overview request for: ${pageUID}`);
+        try {
+            const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
+            const overview = {
+                rows: result.rows?.map((row, rowIndex) => ({
+                    rowIndex,
+                    columns: row.columns?.map((column, colIndex) => ({
+                        columnIndex: colIndex,
+                        proportion: column.proportion,
+                        widgets: column.widgets?.map((widget) => ({
+                            id: widget.id,
+                            widgetType: widget.widgetType,
+                            configurationCount: widget.configuration?.length || 0
+                        })) || []
+                    })) || []
+                })) || []
+            };
+            debugLogWithTag('LAYOUT', `Retrieved 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 ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    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: {
+            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 ({ pageUID, widgetId }) => {
+        debugLogWithTag('LAYOUT', `Starting widget details request for widget ${widgetId} in page ${pageUID}`);
+        try {
+            const result = await client.makeApiRequest('json/pageLayout', 'GET', { pageUID });
+            let foundWidget = null;
+            const findWidget = (rows) => {
+                for (const row of rows || []) {
+                    for (const column of row.columns || []) {
+                        for (const widget of column.widgets || []) {
+                            if (widget.id === widgetId) {
+                                return widget;
+                            }
+                            if (widget.widgetsLayout?.rows) {
+                                const nestedWidget = findWidget(widget.widgetsLayout.rows);
+                                if (nestedWidget)
+                                    return nestedWidget;
+                            }
+                        }
+                    }
+                }
+                return null;
+            };
+            foundWidget = findWidget(result.rows);
+            if (!foundWidget) {
+                return {
+                    content: [{ type: "text", text: `Widget with ID ${widgetId} not found in page ${pageUID}` }]
+                };
+            }
+            debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId}`);
+            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 ${pageUID}: ${error instanceof Error ? error.message : String(error)}` }]
+            };
+        }
+    });
+}
+server.registerTool("cplace_get_current_user", {
+    description: "Get information about the currently logged-in user, including their attributes and metadata",
+    inputSchema: {},
+    annotations: { title: "Get Current User" }
+}, async () => {
+    debugLogWithTag('CURRENT_USER', 'Starting current user request');
+    try {
+        const result = await client.makeApiRequest('json/current-user');
+        debugLogWithTag('CURRENT_USER', `Retrieved current user information`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error retrieving current user information: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+});
+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_only", {
+    description: "Lightweight tool for updating only page attributes (no content or structural changes) using the same 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 Only" }
+}, 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)}` }]
+        };
+    }
+});
+if (config.registerLayoutTools) {
+    server.registerTool("cplace_add_widget_to_layout", {
+        description: "Add a new widget to a page layout at a specific position",
+        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')"),
+            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}`),
+            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")
+        },
+        annotations: { title: "Add Widget to Layout" }
+    }, async ({ pageUID, widgetType, configuration, position }) => {
+        debugLogWithTag('LAYOUT_MODIFY', `Starting add widget operation: ${widgetType} to page ${pageUID} at position ${JSON.stringify(position)}`);
+        try {
+            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,
+                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 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)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    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)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    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)}` }]
+            };
+        }
+    });
+}
+if (config.registerLayoutTools) {
+    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)}` }]
+            };
+        }
+    });
+}
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);