@cplace/mcp-server 1.3.14

package/dist/tools/board-widget.js

@@ -0,0 +1,810 @@
+import { z } from "zod";
+import { debugLogWithTag } from "../logger.js";
+import { LayoutContextSchema } from './layout.js';
+const TOOL_BOARD_GET_CONFIGURATION = 'cplace_board_get_configuration';
+const TOOL_BOARD_CONFIGURE_CARDS = 'cplace_board_configure_cards';
+const TOOL_BOARD_CONFIGURE_COLUMNS = 'cplace_board_configure_columns';
+const TOOL_BOARD_CONFIGURE_SWIMLANES = 'cplace_board_configure_swimlanes';
+const TOOL_BOARD_CONFIGURE_VISUAL = 'cplace_board_configure_visual';
+const BOARD_WIDGET_TYPE = 'cf.cplace.cboard.main.board';
+const DisplayAttributesSchema = z.object({
+    description: z.string().optional().describe("Attribute for card body text"),
+    date: z.string().optional().describe("Attribute for date display"),
+    tags: z.string().optional().describe("Attribute for colored tag pills"),
+    customIcons: z.array(z.string()).optional().describe("Attributes for icon indicators"),
+    additional: z.array(z.string()).optional().describe("Extra attributes shown on card")
+}).optional();
+const CardConfigurationSchema = z.object({
+    searchId: z.string().describe("Unique identifier for this card source - used to link columns/swimlanes"),
+    search: z.string().describe("WARNING: Do not manually construct! Use cplaceJson from cplace_search_pages response. Must have 'filters' array, e.g., {\"filters\":[{\"relativeSpace\":\"true\"},{\"types\":[\"cf.myType\"]}]}"),
+    typeId: z.string().optional().describe("Explicit page type (optional, inferred from search)"),
+    displayAttributes: DisplayAttributesSchema
+});
+const CardsInputSchema = z.array(CardConfigurationSchema)
+    .min(1)
+    .describe("Array of card source configurations. Order determines display priority.");
+const LocalizedNamesSchema = z.object({
+    en: z.string().describe("English name"),
+    de: z.string().optional().describe("German name (optional)")
+});
+const MappingSchema = z.object({
+    searchId: z.string().describe("Must match a searchId from card configurations"),
+    attribute: z.string().describe("Attribute determining placement (e.g., 'cf.myType.status')"),
+    values: z.array(z.string()).describe("Attribute values mapping to this column/swimlane")
+});
+const StaticColumnSchema = z.object({
+    columnId: z.string().describe("Unique identifier for this column"),
+    names: LocalizedNamesSchema,
+    mappings: z.array(MappingSchema).min(1).describe("Value mappings per card source")
+});
+const StaticSwimlaneSchema = z.object({
+    swimlaneId: z.string().describe("Unique identifier for this swimlane"),
+    names: LocalizedNamesSchema,
+    mappings: z.array(MappingSchema).min(1).describe("Value mappings per card source")
+});
+const DynamicConfigSchema = z.object({
+    mappedAttributes: z.array(z.object({
+        searchId: z.string(),
+        attribute: z.string()
+    })).min(1),
+    timeGranularity: z.enum(["day", "week", "month", "quarter", "year"]).optional(),
+    dateRange: z.object({
+        start: z.string(),
+        end: z.string()
+    }).optional(),
+    dateFormatId: z.string().optional()
+});
+const BOARD_TOOL_DEFINITIONS = {
+    [TOOL_BOARD_GET_CONFIGURATION]: {
+        description: `Get current board widget configuration in a structured format suitable for modification.
+
+Returns the current state of:
+- cards: Card sources (searches) with display attribute mappings
+- columns: Column structure (static or dynamic mode)
+- swimlanes: Swimlane structure (if enabled)
+- visualComponents: UI settings and toggles
+
+WORKFLOW: Use this tool first, then modify the relevant section and pass to the corresponding configure tool.`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The board widget ID (e.g., 'id_abc123')")
+        },
+        annotations: { title: "Get Board Configuration" }
+    },
+    [TOOL_BOARD_CONFIGURE_CARDS]: {
+        description: `Configure card sources for a board widget. Declares the complete set of card sources - existing sources not in the array will be removed.
+
+IMPORTANT: Configure cards BEFORE columns/swimlanes, as they reference cards via searchId.
+
+Each card source defines:
+- searchId: Unique identifier used by columns/swimlanes to reference this source
+- search: cplaceJson from cplace_search_pages (defines which pages become cards)
+- displayAttributes: How card data is displayed (description, date, tags, icons)
+
+**WARNING**: Do not manually construct search JSON! The search parameter requires a specific format with a "filters" array.
+
+**Correct Usage**: Use the cplaceJson field from cplace_search_pages response
+
+**Search JSON Workflow**:
+1. Call cplace_search_pages with your desired filter (e.g., types, workspace)
+2. Take the cplaceJson field from the response
+3. Use that value for the search parameter
+
+Example of CORRECT format: {"filters":[{"relativeSpace":"true"},{"types":["cf.myApp.myType"]}]}
+Example of WRONG format: {"types":["cf.myApp.myType"]} (missing filters array - will cause "No value for filters" error)
+
+WORKFLOW:
+1. Get current config: cplace_board_get_configuration
+2. Modify the cards array
+3. Call this tool with the complete desired cards array`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The board widget ID"),
+            cards: CardsInputSchema
+        },
+        annotations: { title: "Configure Board Cards" }
+    },
+    [TOOL_BOARD_CONFIGURE_COLUMNS]: {
+        description: `Configure column structure for a board widget. Declares the complete column configuration.
+
+MODES:
+- static: Explicitly define columns with value mappings (most common)
+- dynamic: Auto-generate columns from attribute values
+
+IMPORTANT: All searchId references must exist in the board's card configurations.
+Configure cards first if adding new card sources.
+
+STATIC MODE: Array order = column order (left to right)
+DYNAMIC MODE: Columns auto-generated; use for date-based or value-based grouping
+
+WORKFLOW:
+1. Ensure cards are configured with desired searchIds
+2. Get current config: cplace_board_get_configuration
+3. Modify or replace columns configuration
+4. Call this tool with complete desired state`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The board widget ID"),
+            mode: z.enum(["static", "dynamic"]).describe("Column generation mode"),
+            columns: z.array(StaticColumnSchema).optional().describe("Static column definitions (required for static mode)"),
+            dynamicConfig: DynamicConfigSchema.optional().describe("Dynamic column configuration (required for dynamic mode)")
+        },
+        annotations: { title: "Configure Board Columns" }
+    },
+    [TOOL_BOARD_CONFIGURE_SWIMLANES]: {
+        description: `Configure swimlane structure for a board widget. Swimlanes create horizontal groupings within columns.
+
+SET enabled: false to remove all swimlanes (flat board).
+
+MODES (when enabled):
+- static: Explicitly define swimlanes with value mappings
+- dynamic: Auto-generate swimlanes from attribute values
+
+IMPORTANT: All searchId references must exist in the board's card configurations.
+
+WORKFLOW:
+1. Ensure cards are configured with desired searchIds
+2. Get current config: cplace_board_get_configuration
+3. Modify or replace swimlanes configuration
+4. Call this tool with complete desired state`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The board widget ID"),
+            enabled: z.boolean().describe("false = no swimlanes (flat board)"),
+            mode: z.enum(["static", "dynamic"]).optional().describe("Swimlane generation mode (required when enabled)"),
+            swimlanes: z.array(StaticSwimlaneSchema).optional().describe("Static swimlane definitions"),
+            dynamicConfig: DynamicConfigSchema.optional().describe("Dynamic swimlane configuration")
+        },
+        annotations: { title: "Configure Board Swimlanes" }
+    },
+    [TOOL_BOARD_CONFIGURE_VISUAL]: {
+        description: `Configure visual settings for a board widget. Controls UI features and display options.
+
+Available settings:
+- showCardCount: Show card count in column headers
+- enableQuickAdd: Show "+" button to create new cards
+- showUnmappedContainer: Show container for cards without valid column mapping
+- enableCardDetailsView: Show card details inline instead of navigation
+- showSpaceAfterLastColumn: Add visual spacing after last column
+- enableRecentHistory: Show button to highlight recently changed cards
+- recentHistoryWeeks: Time range for "recent" cards (default: 2)
+
+Omitted settings retain their current values (this tool does partial updates for visual settings).`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The board widget ID"),
+            showCardCount: z.boolean().optional().describe("Show card count in column headers"),
+            enableQuickAdd: z.boolean().optional().describe("Show '+' button to create new cards"),
+            showUnmappedContainer: z.boolean().optional().describe("Show container for cards without valid column mapping"),
+            unmappedContainerNames: LocalizedNamesSchema.optional().describe("Localized names for unmapped container"),
+            enableCardDetailsView: z.boolean().optional().describe("Show card details inline instead of navigation"),
+            showSpaceAfterLastColumn: z.boolean().optional().describe("Add visual spacing after last column"),
+            enableRecentHistory: z.boolean().optional().describe("Show button to highlight recently changed cards"),
+            recentHistoryWeeks: z.number().optional().describe("Time range for 'recent' cards (default: 2)")
+        },
+        annotations: { title: "Configure Board Visual Settings" }
+    }
+};
+function findWidgetById(rows, widgetId) {
+    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 nested = findWidgetById(widget.widgetsLayout.rows, widgetId);
+                    if (nested)
+                        return nested;
+                }
+            }
+        }
+    }
+    return null;
+}
+function extractWidgetConfiguration(widget) {
+    const config = {};
+    const CBOARD_PREFIX = 'cf.cplace.cboard.';
+    const KNOWN_ATTRS = ['searchConfigurations', 'columnMapping', 'swimlaneMapping', 'visualComponents'];
+    const parseSearchConfigurations = (value) => {
+        return (value || []).map((v) => {
+            try {
+                return JSON.parse(v);
+            }
+            catch {
+                return null;
+            }
+        }).filter((v) => v !== null);
+    };
+    const getShortName = (name) => {
+        return name.startsWith(CBOARD_PREFIX) ? name.slice(CBOARD_PREFIX.length) : name;
+    };
+    if (widget.configuration && typeof widget.configuration === 'object' && !Array.isArray(widget.configuration)) {
+        for (const [key, value] of Object.entries(widget.configuration)) {
+            const shortName = getShortName(key);
+            if (shortName === 'searchConfigurations') {
+                config.searchConfigurations = parseSearchConfigurations(value);
+            }
+            else if (KNOWN_ATTRS.includes(shortName)) {
+                config[shortName] = value;
+            }
+        }
+        return config;
+    }
+    for (const attr of Array.isArray(widget.configuration) ? widget.configuration : []) {
+        const shortName = getShortName(attr.name || '');
+        if (shortName === 'searchConfigurations') {
+            config.searchConfigurations = parseSearchConfigurations(attr.value);
+        }
+        else if (KNOWN_ATTRS.includes(shortName)) {
+            config[shortName] = attr.value;
+        }
+    }
+    return config;
+}
+function validateSearchIdReferences(referencedIds, availableIds, contextDescription) {
+    const invalidIds = referencedIds.filter(id => !availableIds.includes(id));
+    if (invalidIds.length > 0) {
+        return {
+            valid: false,
+            error: `${contextDescription} references unknown searchId(s): ${invalidIds.map(id => `'${id}'`).join(', ')}. ` +
+                `Available searchIds: [${availableIds.map(id => `'${id}'`).join(', ')}]`
+        };
+    }
+    return { valid: true };
+}
+function transformRawToFriendly(rawConfig) {
+    const cards = (rawConfig.searchConfigurations || []).map((sc) => ({
+        searchId: sc.searchId,
+        search: sc.search,
+        typeId: sc.typeId,
+        displayAttributes: sc.attributesConfiguration ? {
+            description: sc.attributesConfiguration.descriptionAttribute,
+            date: sc.attributesConfiguration.dateAttribute,
+            tags: sc.attributesConfiguration.tagsAttribute,
+            customIcons: sc.attributesConfiguration.customIconsAttributes,
+            additional: sc.attributesConfiguration.displayAttributes
+        } : undefined
+    }));
+    let columns = null;
+    if (rawConfig.columnMapping) {
+        try {
+            const columnMapping = typeof rawConfig.columnMapping === 'string'
+                ? JSON.parse(rawConfig.columnMapping)
+                : rawConfig.columnMapping;
+            columns = transformMappingToFriendly(columnMapping, 'column');
+        }
+        catch {
+            columns = null;
+        }
+    }
+    let swimlanes = null;
+    if (rawConfig.swimlaneMapping) {
+        try {
+            const swimlaneMapping = typeof rawConfig.swimlaneMapping === 'string'
+                ? JSON.parse(rawConfig.swimlaneMapping)
+                : rawConfig.swimlaneMapping;
+            swimlanes = transformMappingToFriendly(swimlaneMapping, 'swimlane');
+        }
+        catch {
+            swimlanes = null;
+        }
+    }
+    let visualComponents = {};
+    if (rawConfig.visualComponents) {
+        try {
+            const rawVisual = typeof rawConfig.visualComponents === 'string'
+                ? JSON.parse(rawConfig.visualComponents)
+                : rawConfig.visualComponents;
+            visualComponents = transformVisualToFriendly(rawVisual);
+        }
+        catch {
+            visualComponents = {};
+        }
+    }
+    return { cards, columns, swimlanes, visualComponents };
+}
+function transformMappingToFriendly(raw, elementType) {
+    const idField = elementType === 'column' ? 'columnId' : 'swimlaneId';
+    const pluralField = elementType === 'column' ? 'columns' : 'swimlanes';
+    const hasElements = raw.elements && raw.elements.length > 0;
+    const hasMappedAttributes = raw.mappedAttributes && raw.mappedAttributes.length > 0;
+    if (!hasElements && !hasMappedAttributes) {
+        return elementType === 'swimlane' ? { enabled: false } : null;
+    }
+    if (raw.dynamic) {
+        return {
+            mode: "dynamic",
+            ...(elementType === 'swimlane' && { enabled: true }),
+            dynamicConfig: {
+                mappedAttributes: raw.mappedAttributes?.map((ma) => ({
+                    searchId: ma.searchId,
+                    attribute: ma.attributeSimpleName
+                })),
+                timeGranularity: raw.timeGranularity?.toLowerCase(),
+                dateRange: raw.dateRange,
+                dateFormatId: raw.dateFormatId
+            }
+        };
+    }
+    return {
+        mode: "static",
+        ...(elementType === 'swimlane' && { enabled: true }),
+        [pluralField]: raw.elements?.map((el) => ({
+            [idField]: el.id,
+            names: el.localizedNames,
+            mappings: el.mappedValues?.map((mv) => ({
+                searchId: mv.searchId,
+                attribute: raw.mappedAttributes?.find((ma) => ma.searchId === mv.searchId)?.attributeSimpleName,
+                values: mv.values
+            }))
+        }))
+    };
+}
+function transformVisualToFriendly(raw) {
+    return {
+        showCardCount: raw.cardCountEnabled,
+        enableQuickAdd: raw.addCardButtonEnabled,
+        showUnmappedContainer: raw.unmappedCardsContainerEnabled,
+        unmappedContainerNames: raw.unmappedCardsContainerLocalizedNames,
+        enableCardDetailsView: raw.cardDetailsViewEnabled,
+        showSpaceAfterLastColumn: raw.spaceAfterLastColumnEnabled,
+        enableRecentHistory: raw.recentHistoryButtonEnabled,
+        recentHistoryWeeks: raw.recentHistoryTimeRangeWeeks
+    };
+}
+function transformCardsToRaw(cards) {
+    return cards.map(card => ({
+        searchId: card.searchId,
+        search: card.search,
+        typeId: card.typeId,
+        attributesConfiguration: card.displayAttributes ? {
+            descriptionAttribute: card.displayAttributes.description,
+            dateAttribute: card.displayAttributes.date,
+            tagsAttribute: card.displayAttributes.tags,
+            customIconsAttributes: card.displayAttributes.customIcons,
+            displayAttributes: card.displayAttributes.additional
+        } : undefined
+    }));
+}
+function transformColumnsToRaw(columnsConfig) {
+    if (columnsConfig.mode === "dynamic") {
+        return JSON.stringify({
+            dynamic: true,
+            mappedAttributes: columnsConfig.dynamicConfig.mappedAttributes.map((ma) => ({
+                searchId: ma.searchId,
+                attributeSimpleName: ma.attribute
+            })),
+            timeGranularity: columnsConfig.dynamicConfig.timeGranularity?.toUpperCase(),
+            dateRange: columnsConfig.dynamicConfig.dateRange,
+            dateFormatId: columnsConfig.dynamicConfig.dateFormatId,
+            elements: []
+        });
+    }
+    const mappedAttributesMap = new Map();
+    columnsConfig.columns.forEach((col) => {
+        col.mappings.forEach((m) => {
+            mappedAttributesMap.set(m.searchId, m.attribute);
+        });
+    });
+    return JSON.stringify({
+        dynamic: false,
+        mappedAttributes: Array.from(mappedAttributesMap.entries()).map(([searchId, attr]) => ({
+            searchId,
+            attributeSimpleName: attr
+        })),
+        elements: columnsConfig.columns.map((col) => ({
+            id: col.columnId,
+            localizedNames: col.names,
+            mappedValues: col.mappings.map((m) => ({
+                searchId: m.searchId,
+                values: m.values
+            }))
+        }))
+    });
+}
+function transformSwimlanesToRaw(swimlanesConfig) {
+    if (!swimlanesConfig.enabled) {
+        return JSON.stringify({
+            dynamic: false,
+            mappedAttributes: [],
+            elements: []
+        });
+    }
+    if (swimlanesConfig.mode === "dynamic") {
+        return JSON.stringify({
+            dynamic: true,
+            mappedAttributes: swimlanesConfig.dynamicConfig.mappedAttributes.map((ma) => ({
+                searchId: ma.searchId,
+                attributeSimpleName: ma.attribute
+            })),
+            timeGranularity: swimlanesConfig.dynamicConfig.timeGranularity?.toUpperCase(),
+            dateRange: swimlanesConfig.dynamicConfig.dateRange,
+            dateFormatId: swimlanesConfig.dynamicConfig.dateFormatId,
+            elements: []
+        });
+    }
+    const mappedAttributesMap = new Map();
+    swimlanesConfig.swimlanes.forEach((sl) => {
+        sl.mappings.forEach((m) => {
+            mappedAttributesMap.set(m.searchId, m.attribute);
+        });
+    });
+    return JSON.stringify({
+        dynamic: false,
+        mappedAttributes: Array.from(mappedAttributesMap.entries()).map(([searchId, attr]) => ({
+            searchId,
+            attributeSimpleName: attr
+        })),
+        elements: swimlanesConfig.swimlanes.map((sl) => ({
+            id: sl.swimlaneId,
+            localizedNames: sl.names,
+            mappedValues: sl.mappings.map((m) => ({
+                searchId: m.searchId,
+                values: m.values
+            }))
+        }))
+    });
+}
+function transformVisualToRaw(friendlyVisual) {
+    const fieldMapping = {
+        showCardCount: 'cardCountEnabled',
+        enableQuickAdd: 'addCardButtonEnabled',
+        showUnmappedContainer: 'unmappedCardsContainerEnabled',
+        unmappedContainerNames: 'unmappedCardsContainerLocalizedNames',
+        enableCardDetailsView: 'cardDetailsViewEnabled',
+        showSpaceAfterLastColumn: 'spaceAfterLastColumnEnabled',
+        enableRecentHistory: 'recentHistoryButtonEnabled',
+        recentHistoryWeeks: 'recentHistoryTimeRangeWeeks'
+    };
+    const raw = {};
+    for (const [friendlyName, rawName] of Object.entries(fieldMapping)) {
+        if (friendlyVisual[friendlyName] !== undefined) {
+            raw[rawName] = friendlyVisual[friendlyName];
+        }
+    }
+    return raw;
+}
+function buildUpdateRequestBody(context, widgetId, configuration) {
+    const baseParams = context.type === "page"
+        ? { pageUID: context.pageUID }
+        : {
+            workspaceId: context.workspaceId,
+            typeInternalName: context.typeInternalName,
+            ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName })
+        };
+    return {
+        ...baseParams,
+        operation: {
+            type: "UPDATE",
+            widgetId,
+            newConfiguration: configuration
+        }
+    };
+}
+async function getCurrentBoardConfig(client, context, widgetId) {
+    try {
+        const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+        const params = context.type === "page"
+            ? { pageUID: context.pageUID }
+            : {
+                workspaceId: context.workspaceId,
+                typeInternalName: context.typeInternalName,
+                ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName })
+            };
+        const layoutResult = await client.makeApiRequest(endpoint, 'GET', params);
+        const widget = findWidgetById(layoutResult.rows, widgetId);
+        if (!widget) {
+            return { error: `Board widget '${widgetId}' not found` };
+        }
+        if (widget.widgetType !== BOARD_WIDGET_TYPE) {
+            return { error: `Widget '${widgetId}' is not a board widget (found: ${widget.widgetType})` };
+        }
+        const rawConfig = extractWidgetConfiguration(widget);
+        const friendlyConfig = transformRawToFriendly(rawConfig);
+        return {
+            cards: friendlyConfig.cards,
+            visualComponents: friendlyConfig.visualComponents
+        };
+    }
+    catch (error) {
+        return { error: `Failed to get current configuration: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+export function registerBoardWidgetTools(server, client) {
+    server.registerTool(TOOL_BOARD_GET_CONFIGURATION, BOARD_TOOL_DEFINITIONS[TOOL_BOARD_GET_CONFIGURATION], async ({ context, widgetId }) => {
+        debugLogWithTag('BOARD', `Getting board configuration for widget ${widgetId}`);
+        try {
+            const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+            const params = context.type === "page"
+                ? { pageUID: context.pageUID }
+                : {
+                    workspaceId: context.workspaceId,
+                    typeInternalName: context.typeInternalName,
+                    ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName })
+                };
+            const layoutResult = await client.makeApiRequest(endpoint, 'GET', params);
+            const widget = findWidgetById(layoutResult.rows, widgetId);
+            if (!widget) {
+                return {
+                    content: [{ type: "text", text: `Board widget with ID '${widgetId}' not found in layout` }],
+                    isError: true
+                };
+            }
+            if (widget.widgetType !== BOARD_WIDGET_TYPE) {
+                return {
+                    content: [{ type: "text", text: `Widget '${widgetId}' is not a board widget (found: ${widget.widgetType})` }],
+                    isError: true
+                };
+            }
+            const rawConfig = extractWidgetConfiguration(widget);
+            const isUnconfigured = (!rawConfig.searchConfigurations || rawConfig.searchConfigurations.length === 0)
+                && !rawConfig.columnMapping
+                && !rawConfig.swimlaneMapping;
+            if (isUnconfigured) {
+                debugLogWithTag('BOARD', `Board widget ${widgetId} is unconfigured (no card sources or mappings)`);
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                context,
+                                widgetId,
+                                configuration: {
+                                    status: "unconfigured",
+                                    cards: [],
+                                    columns: null,
+                                    swimlanes: null,
+                                    visualComponents: null
+                                }
+                            }, null, 2) }]
+                };
+            }
+            const friendlyConfig = transformRawToFriendly(rawConfig);
+            debugLogWithTag('BOARD', `Successfully retrieved board configuration with ${friendlyConfig.cards?.length || 0} card sources`);
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            context,
+                            widgetId,
+                            configuration: {
+                                status: "configured",
+                                ...friendlyConfig
+                            }
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('BOARD', `Error getting board configuration: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Failed to get board configuration: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_BOARD_CONFIGURE_CARDS, BOARD_TOOL_DEFINITIONS[TOOL_BOARD_CONFIGURE_CARDS], async ({ context, widgetId, cards }) => {
+        debugLogWithTag('BOARD', `Configuring ${cards.length} card sources for widget ${widgetId}`);
+        try {
+            const searchIds = cards.map(c => c.searchId);
+            const duplicates = searchIds.filter((id, i) => searchIds.indexOf(id) !== i);
+            if (duplicates.length > 0) {
+                return {
+                    content: [{ type: "text", text: `Duplicate searchId(s) found: ${[...new Set(duplicates)].join(', ')}. Each searchId must be unique.` }],
+                    isError: true
+                };
+            }
+            const rawSearchConfigurations = transformCardsToRaw(cards);
+            const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+            const searchConfigurationsValue = rawSearchConfigurations.map(sc => JSON.stringify(sc));
+            debugLogWithTag('BOARD', `searchConfigurationsValue: ${JSON.stringify(searchConfigurationsValue)}`);
+            const requestBody = buildUpdateRequestBody(context, widgetId, {
+                'cf.cplace.cboard.searchConfigurations': searchConfigurationsValue
+            });
+            await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('BOARD', `Successfully configured ${cards.length} card sources`);
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            operation: "CONFIGURE_CARDS",
+                            status: "SUCCESS",
+                            context,
+                            widgetId,
+                            cardCount: cards.length,
+                            searchIds: searchIds,
+                            message: `Board cards configured successfully with ${cards.length} source(s)`
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('BOARD', `Error configuring cards: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Failed to configure board cards: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_BOARD_CONFIGURE_COLUMNS, BOARD_TOOL_DEFINITIONS[TOOL_BOARD_CONFIGURE_COLUMNS], async ({ context, widgetId, mode, columns, dynamicConfig }) => {
+        debugLogWithTag('BOARD', `Configuring columns (${mode} mode) for widget ${widgetId}`);
+        try {
+            if (mode === "static" && (!columns || columns.length === 0)) {
+                return {
+                    content: [{ type: "text", text: "Static mode requires at least one column definition" }],
+                    isError: true
+                };
+            }
+            if (mode === "dynamic" && !dynamicConfig) {
+                return {
+                    content: [{ type: "text", text: "Dynamic mode requires dynamicConfig" }],
+                    isError: true
+                };
+            }
+            const currentConfig = await getCurrentBoardConfig(client, context, widgetId);
+            if (currentConfig.error) {
+                return {
+                    content: [{ type: "text", text: currentConfig.error }],
+                    isError: true
+                };
+            }
+            const availableSearchIds = currentConfig.cards?.map((c) => c.searchId) || [];
+            const referencedIds = mode === "static"
+                ? [...new Set(columns.flatMap(col => col.mappings.map(m => m.searchId)))]
+                : (dynamicConfig?.mappedAttributes || []).map(ma => ma.searchId);
+            const validation = validateSearchIdReferences(referencedIds, availableSearchIds, "Column configuration");
+            if (!validation.valid) {
+                return {
+                    content: [{ type: "text", text: validation.error }],
+                    isError: true
+                };
+            }
+            const rawColumnMapping = transformColumnsToRaw({ mode, columns, dynamicConfig });
+            const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+            const requestBody = buildUpdateRequestBody(context, widgetId, {
+                'cf.cplace.cboard.columnMapping': rawColumnMapping
+            });
+            await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('BOARD', `Successfully configured columns in ${mode} mode`);
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            operation: "CONFIGURE_COLUMNS",
+                            status: "SUCCESS",
+                            context,
+                            widgetId,
+                            mode,
+                            columnCount: mode === "static" ? columns.length : "dynamic",
+                            message: `Board columns configured successfully (${mode} mode)`
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('BOARD', `Error configuring columns: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Failed to configure board columns: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_BOARD_CONFIGURE_SWIMLANES, BOARD_TOOL_DEFINITIONS[TOOL_BOARD_CONFIGURE_SWIMLANES], async ({ context, widgetId, enabled, mode, swimlanes, dynamicConfig }) => {
+        debugLogWithTag('BOARD', `Configuring swimlanes (enabled: ${enabled}) for widget ${widgetId}`);
+        try {
+            if (!enabled) {
+                const rawSwimlaneMapping = transformSwimlanesToRaw({ enabled: false });
+                const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+                const requestBody = buildUpdateRequestBody(context, widgetId, {
+                    'cf.cplace.cboard.swimlaneMapping': rawSwimlaneMapping
+                });
+                await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                operation: "CONFIGURE_SWIMLANES",
+                                status: "SUCCESS",
+                                context,
+                                widgetId,
+                                enabled: false,
+                                message: "Board swimlanes disabled (flat board)"
+                            }, null, 2) }]
+                };
+            }
+            if (!mode) {
+                return {
+                    content: [{ type: "text", text: "Mode is required when swimlanes are enabled" }],
+                    isError: true
+                };
+            }
+            if (mode === "static" && (!swimlanes || swimlanes.length === 0)) {
+                return {
+                    content: [{ type: "text", text: "Static mode requires at least one swimlane definition" }],
+                    isError: true
+                };
+            }
+            if (mode === "dynamic" && !dynamicConfig) {
+                return {
+                    content: [{ type: "text", text: "Dynamic mode requires dynamicConfig" }],
+                    isError: true
+                };
+            }
+            const currentConfig = await getCurrentBoardConfig(client, context, widgetId);
+            if (currentConfig.error) {
+                return {
+                    content: [{ type: "text", text: currentConfig.error }],
+                    isError: true
+                };
+            }
+            const availableSearchIds = currentConfig.cards?.map((c) => c.searchId) || [];
+            const referencedIds = mode === "static"
+                ? [...new Set(swimlanes.flatMap(sl => sl.mappings.map(m => m.searchId)))]
+                : (dynamicConfig?.mappedAttributes || []).map(ma => ma.searchId);
+            const validation = validateSearchIdReferences(referencedIds, availableSearchIds, "Swimlane configuration");
+            if (!validation.valid) {
+                return {
+                    content: [{ type: "text", text: validation.error }],
+                    isError: true
+                };
+            }
+            const rawSwimlaneMapping = transformSwimlanesToRaw({ enabled: true, mode, swimlanes, dynamicConfig });
+            const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+            const requestBody = buildUpdateRequestBody(context, widgetId, {
+                'cf.cplace.cboard.swimlaneMapping': rawSwimlaneMapping
+            });
+            await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('BOARD', `Successfully configured swimlanes in ${mode} mode`);
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            operation: "CONFIGURE_SWIMLANES",
+                            status: "SUCCESS",
+                            context,
+                            widgetId,
+                            enabled: true,
+                            mode,
+                            swimlaneCount: mode === "static" ? swimlanes.length : "dynamic",
+                            message: `Board swimlanes configured successfully (${mode} mode)`
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('BOARD', `Error configuring swimlanes: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Failed to configure board swimlanes: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_BOARD_CONFIGURE_VISUAL, BOARD_TOOL_DEFINITIONS[TOOL_BOARD_CONFIGURE_VISUAL], async ({ context, widgetId, ...visualSettings }) => {
+        debugLogWithTag('BOARD', `Configuring visual settings for widget ${widgetId}`);
+        try {
+            const currentConfig = await getCurrentBoardConfig(client, context, widgetId);
+            if (currentConfig.error) {
+                return {
+                    content: [{ type: "text", text: currentConfig.error }],
+                    isError: true
+                };
+            }
+            const currentVisual = currentConfig.visualComponents || {};
+            const currentRaw = transformVisualToRaw(currentVisual);
+            const newRaw = transformVisualToRaw(visualSettings);
+            const mergedRaw = { ...currentRaw, ...newRaw };
+            const rawVisualComponents = JSON.stringify(mergedRaw);
+            const endpoint = context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+            const requestBody = buildUpdateRequestBody(context, widgetId, {
+                'cf.cplace.cboard.visualComponents': rawVisualComponents
+            });
+            await client.makeApiRequest(endpoint, 'PATCH', undefined, requestBody);
+            debugLogWithTag('BOARD', `Successfully configured visual settings`);
+            const appliedSettings = Object.keys(visualSettings).filter(k => visualSettings[k] !== undefined);
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            operation: "CONFIGURE_VISUAL",
+                            status: "SUCCESS",
+                            context,
+                            widgetId,
+                            appliedSettings,
+                            message: "Board visual settings configured successfully"
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('BOARD', `Error configuring visual settings: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{ type: "text", text: `Failed to configure board visual settings: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    debugLogWithTag('BOARD', 'Registered 5 board widget configuration tools');
+}
+export { BOARD_TOOL_DEFINITIONS };
+//# sourceMappingURL=board-widget.js.map