@cplace/test-mcp-server 0.1.9 → 0.1.11

package/dist/index.js

@@ -2,14 +2,11 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import * as dotenv from 'dotenv';
-import { z } from "zod";
 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";
+import { parseProfiles, getActiveTools, TOOL_GROUPS } from './profiles.js';
+import { registerActiveTools } from './conditional-registration.js';
+import { registerSystemTools } from './tools/system.js';
+import { debugLogWithTag } from './logger.js';
 dotenv.config();
 const config = {
     url: process.env.CPLACE_URL || '',
@@ -17,1140 +14,63 @@ const config = {
     registerSystemInfoTool: process.env.REGISTER_SYSTEM_INFO_TOOL === 'true' || false,
 };
 const client = new CplaceApiClient(config);
+const activeGroups = parseProfiles(process.argv);
+const activeTools = getActiveTools(activeGroups);
+debugLogWithTag('MCP', '====================================');
+debugLogWithTag('MCP', 'cplace MCP Server Profile Configuration');
+debugLogWithTag('MCP', '====================================');
+debugLogWithTag('MCP', `Active groups: ${Array.from(activeGroups).join(', ')}`);
+debugLogWithTag('MCP', `Total tools to register: ${activeTools.size}`);
+debugLogWithTag('MCP', '====================================');
 const server = new McpServer({
-    name: "cplace-mcp-server",
+    name: `cplace-mcp-server`,
     version: "1.0.0"
 });
-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: "Get 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)",
+registerActiveTools(server, client, activeGroups);
+registerSystemTools(server, config);
+server.registerTool("cplace_profile_info", {
+    description: "Get information about active MCP profiles and available groups",
     inputSchema: {},
-    annotations: { title: "List Workspaces" }
+    annotations: { title: "Profile Information" }
 }, async () => {
-    debugLogWithTag('WORKSPACES', 'Starting workspace list request');
-    try {
-        const workspaces = await client.makeApiRequest('json/workspaces');
-        const filteredWorkspaces = workspaces.map((workspace) => ({
-            id: workspace.id,
-            name: workspace.name,
-            displayName: workspace.displayName,
-            totalPages: workspace.totalPages,
-            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) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving workspaces: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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: "List Types" }
-}, async ({ workspaceId }) => {
-    try {
-        const workspaces = await client.makeApiRequest('json/workspaces');
-        const workspace = workspaces.find((w) => w.id === workspaceId);
-        if (workspace) {
-            const types = workspace.typeDefinitions?.types || [];
-            return {
-                content: [{ type: "text", text: JSON.stringify(types, null, 2) }]
-            };
-        }
-        return {
-            content: [{ type: "text", text: `Workspace ${workspaceId} not found` }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving types: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_type_datamodel", {
-    description: "Get the datamodel of a type including its attributes, constraints, and permissions. Use this before performing a search to understand the type structure.",
-    inputSchema: {
-        workspaceId: z.string().describe("The ID of the workspace"),
-        internalName: z.string().describe("The internal name of the type")
-    },
-    annotations: { title: "Get Type Details" }
-}, async ({ workspaceId, internalName }) => {
-    try {
-        const result = await client.makeApiRequest('json/type-definition', 'GET', {
-            workspaceId,
-            internalName
-        });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving type details: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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: {
-        id: z.string().describe("The ID of the page to get, e.g. 'page/kkt8ol745jqur4581kelm5ply'")
-    },
-    annotations: { title: "Get Page by ID" }
-}, async ({ id }) => {
-    try {
-        const result = await client.makeApiRequest('json/page', 'GET', { pageUID: id });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving page: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_get_person_by_id", {
-    description: "Get details about a person including their name and email.",
-    inputSchema: {
-        id: z.string().describe("The ID of the person to get, e.g. 'person/kkt8ol745jqur4581kelm5ply'")
-    },
-    annotations: { title: "Get Person by ID" }
-}, async ({ id }) => {
-    try {
-        const result = await client.makeApiRequest('json/person', 'GET', { id });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving person: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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 Name" }
-}, async ({ name }) => {
-    try {
-        const result = await client.makeApiRequest('json/person', 'GET', { name });
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error searching for person: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-server.registerTool("cplace_search_pages", {
-    description: "Search pages of a type in cplace.",
-    inputSchema: {
-        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 ({ 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);
-        debugLogWithTag('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('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: responseFormat === "minimal",
-            includeAttributes: responseFormat !== "minimal",
-            includeMetadata: false,
-            attributeFields: attributes,
-            truncateLargeValues: true
-        })) : [];
-        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,
-            cplaceJson: result.cplaceJson
-        };
-        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)}` }]
-        };
-    }
-});
-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 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 by Fulltext" }
-}, async ({ workspaceId, fulltext, limit = 50, offset = 0, }) => {
-    if (!fulltext) {
-        return {
-            content: [{ type: "text", text: "fulltext is required" }]
-        };
-    }
-    try {
-        const result = await client.makeApiRequest('json/fulltext-search', 'GET', {
-            spaceId: workspaceId,
-            fulltext: `"${fulltext}"`,
-            limit,
-            offset
-        });
-        const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: false,
-            includeAttributes: true,
-            includeMetadata: false,
-            truncateLargeValues: true
-        })) : [];
-        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,
-            cplaceJson: result.cplaceJson
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(filteredResult, null, 2) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error converting or executing search: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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: "List Pages of Type" }
-}, async ({ workspaceId, typeName, limit = 50, offset = 0, }) => {
-    try {
-        const cplaceFilter = {
-            filters: [
-                {
-                    type: "Workspace",
-                    workspaceIds: [workspaceId]
-                },
-                {
-                    type: "Type",
-                    types: [typeName]
-                }
-            ]
-        };
-        const result = await client.makeApiRequest('json/search', 'GET', {
-            filter: JSON.stringify(cplaceFilter),
-            limit,
-            offset
-        });
-        const filteredResults = result.results ? result.results.map((item) => filterSearchResult(item, {
-            minimal: false,
-            includeAttributes: true,
-            includeMetadata: false,
-            truncateLargeValues: true
-        })) : [];
-        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) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving pages: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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)}` }]
-        };
-    }
-});
-server.registerTool("cplace_list_widget_definitions", {
-    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 ({ embeddingContext = "AS_WIDGET" }) => {
-    debugLogWithTag('WIDGETS', `Starting widget definitions list request with embeddingContext: ${embeddingContext}`);
-    try {
-        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) }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error retrieving widget definitions: ${error instanceof Error ? error.message : String(error)}` }]
-        };
-    }
-});
-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)}` }]
-        };
-    }
-});
-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 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 ${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: {
-        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;
-                        }
+    const groupDetails = Array.from(activeGroups).map(name => ({
+        name,
+        description: TOOL_GROUPS[name]?.description || 'Unknown group',
+        toolCount: TOOL_GROUPS[name]?.tools.length || 0,
+        tools: TOOL_GROUPS[name]?.tools || []
+    }));
+    const allGroups = Object.entries(TOOL_GROUPS).map(([name, group]) => ({
+        name,
+        description: group.description,
+        toolCount: group.tools.length,
+        active: activeGroups.has(name)
+    }));
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    active_groups: Array.from(activeGroups),
+                    total_active_tools: activeTools.size,
+                    active_group_details: groupDetails,
+                    all_available_groups: allGroups,
+                    usage_examples: {
+                        minimal: "No --profiles argument (core only)",
+                        page_editing: "--profiles=pages_write",
+                        dashboard_dev: "--profiles=pages_write+layouts",
+                        type_dev: "--profiles=types_write+low_code",
+                        full_access: "--profiles=all"
                     }
-                }
-            }
-            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} 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 ${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", {
-    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)}` }]
-        };
-    }
+                }, null, 2)
+            }]
+    };
 });
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("cplace MCP Server running on stdio");
+    debugLogWithTag('MCP', 'Server running on stdio');
 }
 runServer().catch((error) => {
-    console.error("Fatal error running server:", error);
+    debugLogWithTag('MCP', `Fatal error running server: ${error}`);
     process.exit(1);
 });
 //# sourceMappingURL=index.js.map