@cplace/test-mcp-server 1.1.6 → 1.2.1

package/dist/tools/csv-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csv-export.d.ts","sourceRoot":"","sources":["../../src/tools/csv-export.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"csv-export.d.ts","sourceRoot":"","sources":["../../src/tools/csv-export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAU5C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa9B,CAAC;AAEX,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,QAgEhF"}

package/dist/tools/layout-script.d.ts

@@ -0,0 +1,166 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { CplaceApiClient } from '../api.js';
+export declare const LayoutContextSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"page">;
+    pageUID: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "page";
+    pageUID: string;
+}, {
+    type: "page";
+    pageUID: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"type">;
+    workspaceId: z.ZodString;
+    typeInternalName: z.ZodString;
+    alternativeLayoutName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "type";
+    workspaceId: string;
+    typeInternalName: string;
+    alternativeLayoutName?: string | undefined;
+}, {
+    type: "type";
+    workspaceId: string;
+    typeInternalName: string;
+    alternativeLayoutName?: string | undefined;
+}>]>;
+export declare const LAYOUT_SCRIPT_TOOL_DEFINITIONS: {
+    readonly cplace_layout_script: {
+        readonly description: "Execute a JavaScript layout script to define a complete page or type layout atomically using layout.define().\n\nWHEN TO USE:\n- Use this tool when you know the full layout structure upfront\n- Replaces the entire layout in a single atomic operation (no partial updates)\n- More efficient than sequential add-row/add-widget calls for complete layouts\n\nKEY BEHAVIORS:\n- The script must call layout.define() exactly once\n- The entire layout is atomically replaced — previous layout is fully overwritten\n- Script timeout: 30 seconds\n- Widget IDs: auto-generated if omitted; if provided without '_' prefix, '_' is prepended automatically\n\nRESPONSE OUTCOMES:\n- VALID_COMPLETE: Layout saved, all widgets fully configured\n- VALID_INCOMPLETE: Layout saved, but some widgets have missing optional configuration (warnings returned)\n- Validation errors: Layout NOT saved — structural or widget errors returned with details\n- Generic errors: Entity not found, permission denied, script errors\n\nVALIDATION FEEDBACK:\n- Structural errors: invalid column proportions (must be 3-12 each, sum to 12 per row)\n- Widget errors: unknown widget types, invalid configurations\n- Warnings: widgets saved but missing optional configuration (e.g., search filter not set)\n\nTIP: After a VALID_INCOMPLETE response, re-run layout.define() with corrected widget configuration to resolve warnings.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly script: z.ZodString;
+        };
+        readonly annotations: {
+            readonly title: "Execute Layout Script";
+        };
+    };
+    readonly cplace_layout_get_overview: {
+        readonly description: "Get layout structure for page or type. Provides an overview of the layout grid including rows, columns, and widget summaries for both page and type layouts.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+        };
+        readonly annotations: {
+            readonly title: "Get Layout Overview";
+        };
+    };
+    readonly cplace_layout_get_widget_details: {
+        readonly description: "Get detailed widget configuration from page or type layout. Extracts specific widget information from the layout structure.";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+            readonly widgetId: z.ZodString;
+        };
+        readonly annotations: {
+            readonly title: "Get Widget Details from Layout";
+        };
+    };
+    readonly cplace_layout_get_script: {
+        readonly description: "Get the current layout as a layout.define() JavaScript script for a page or type layout.\n\nWHEN TO USE:\n- To read the current layout before modifying it (read-edit-write workflow)\n- To inspect the full layout definition including widget configurations and embedded layouts\n- To copy a layout from one page/type to another\n\nRETURNS:\n- The layout as a layout.define({...}) script string, ready to be modified and posted back via cplace_layout_script\n- Widget config values are in the INPUT format accepted by cplace_layout_script (references as UID strings, rich strings as markup strings, localized strings as {locale: value} maps)\n\nROUND-TRIP WORKFLOW:\n1. GET: Use this tool to retrieve the current layout script\n2. EDIT: Modify the script as needed\n3. POST: Use cplace_layout_script to apply the modified script";
+        readonly inputSchema: {
+            readonly context: z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"page">;
+                pageUID: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page";
+                pageUID: string;
+            }, {
+                type: "page";
+                pageUID: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"type">;
+                workspaceId: z.ZodString;
+                typeInternalName: z.ZodString;
+                alternativeLayoutName: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }, {
+                type: "type";
+                workspaceId: string;
+                typeInternalName: string;
+                alternativeLayoutName?: string | undefined;
+            }>]>;
+        };
+        readonly annotations: {
+            readonly title: "Get Layout Script";
+        };
+    };
+};
+export declare function registerLayoutScriptTools(server: McpServer, client: CplaceApiClient): void;
+//# sourceMappingURL=layout-script.d.ts.map

package/dist/tools/layout-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-script.d.ts","sourceRoot":"","sources":["../../src/tools/layout-script.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAK5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;IAW+C,CAAC;AAYhF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMjC,CAAC;AAkCX,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,QA2RnF"}

package/dist/tools/layout-script.js

@@ -0,0 +1,474 @@
+import { z } from "zod";
+import { debugLogWithTag } from "../logger.js";
+import { checkResponseSize } from "../utils.js";
+export const LayoutContextSchema = z.union([
+    z.object({
+        type: z.literal("page"),
+        pageUID: z.string().describe("Page UID (e.g., 'page/abc123')")
+    }),
+    z.object({
+        type: z.literal("type"),
+        workspaceId: z.string().describe("Workspace ID (e.g., 'workspace123')"),
+        typeInternalName: z.string().describe("Type internal name (e.g., 'cf.example.myType')"),
+        alternativeLayoutName: z.string().optional().describe("Alternative layout name (optional)")
+    })
+]).describe("Layout target - specify whether operating on page or type layout");
+const TOOL_LAYOUT_SCRIPT = 'cplace_layout_script';
+const TOOL_LAYOUT_GET_OVERVIEW = 'cplace_layout_get_overview';
+const TOOL_LAYOUT_GET_WIDGET_DETAILS = 'cplace_layout_get_widget_details';
+const TOOL_LAYOUT_GET_SCRIPT = 'cplace_layout_get_script';
+export const LAYOUT_SCRIPT_TOOL_DEFINITIONS = {
+    [TOOL_LAYOUT_SCRIPT]: {
+        description: `Execute a JavaScript layout script to define a complete page or type layout atomically using layout.define().
+
+WHEN TO USE:
+- Use this tool when you know the full layout structure upfront
+- Replaces the entire layout in a single atomic operation (no partial updates)
+- More efficient than sequential add-row/add-widget calls for complete layouts
+
+KEY BEHAVIORS:
+- The script must call layout.define() exactly once
+- The entire layout is atomically replaced — previous layout is fully overwritten
+- Script timeout: 30 seconds
+- Widget IDs: auto-generated if omitted; if provided without '_' prefix, '_' is prepended automatically
+
+RESPONSE OUTCOMES:
+- VALID_COMPLETE: Layout saved, all widgets fully configured
+- VALID_INCOMPLETE: Layout saved, but some widgets have missing optional configuration (warnings returned)
+- Validation errors: Layout NOT saved — structural or widget errors returned with details
+- Generic errors: Entity not found, permission denied, script errors
+
+VALIDATION FEEDBACK:
+- Structural errors: invalid column proportions (must be 3-12 each, sum to 12 per row)
+- Widget errors: unknown widget types, invalid configurations
+- Warnings: widgets saved but missing optional configuration (e.g., search filter not set)
+
+TIP: After a VALID_INCOMPLETE response, re-run layout.define() with corrected widget configuration to resolve warnings.`,
+        inputSchema: {
+            context: LayoutContextSchema,
+            script: z.string().describe(`JavaScript code that calls layout.define() exactly once to declare the complete layout structure.
+
+LAYOUT SPECIFICATION FORMAT:
+layout.define({
+  rows: [
+    {
+      columns: [
+        {
+          proportion: 6,        // Column width: integer 3-12, all columns in a row must sum to 12
+          widgets: [
+            {
+              id: "myWidget",   // Optional: explicit widget ID (auto-prefixed with '_' if missing prefix)
+              type: "cf.platform.wiki",  // Required: widget type identifier
+              config: {         // Optional: widget configuration key-value pairs
+                title: "My Wiki"
+              },
+              embeddedLayouts: {  // Optional: nested layouts for container widgets
+                "widgetsLayout": {  // key is the name of the layout attribute
+                  rows: [ /* same recursive structure */ ]
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+});
+
+COLUMN PROPORTION RULES:
+- Each column proportion must be between 3 and 12
+- All column proportions in a row must sum to exactly 12
+- Common patterns: [12] (full width), [6,6] (two equal), [4,4,4] (three equal), [8,4] (main + sidebar), [3,9] (sidebar + main)
+
+WIDGET FIELDS:
+- id (optional): Explicit widget ID. Auto-prefixed with '_' if it doesn't start with '_'. Auto-generated if omitted.
+- type (required): Widget type identifier (e.g., 'cf.platform.wiki', 'cf.platform.embeddedSearchAsTable', 'cf.platform.comments', 'cf.platform.files')
+- config (optional): Key-value object of widget configuration. Keys are attribute names, values are strings, numbers, or booleans.
+- embeddedLayouts (optional): Object mapping layout attribute names to nested layout specs. Used for container widgets (tab groups, attributes groups).
+
+ADDITIONAL APIS:
+Scripts have access to cplace low-code JavaScript APIs for dynamic layout generation:
+- new Search() / Filters.* — Search for pages to build dynamic layouts
+- cplace.utils() — Platform utilities
+- Standard JavaScript (JSON, Array, etc.)
+
+EXAMPLES:
+
+Simple single-column layout:
+layout.define({
+  rows: [
+    { columns: [{ proportion: 12, widgets: [{ type: "cf.platform.wiki" }] }] }
+  ]
+});
+
+Two-column layout with configured widgets:
+layout.define({
+  rows: [
+    {
+      columns: [
+        {
+          proportion: 8,
+          widgets: [
+            { type: "cf.platform.wiki" },
+            { type: "cf.platform.embeddedSearchAsTable", config: { height: 600, search: '{"filters":[{"typeNames":["cf.project.Task"]}]}' } }
+          ]
+        },
+        {
+          proportion: 4,
+          widgets: [
+            { type: "cf.platform.comments" },
+            { type: "cf.platform.files" }
+          ]
+        }
+      ]
+    }
+  ]
+});
+
+Multi-row layout with explicit widget IDs:
+layout.define({
+  rows: [
+    { columns: [{ proportion: 12, widgets: [{ id: "header", type: "cf.platform.wiki", config: { title: "Project Overview" } }] }] },
+    {
+      columns: [
+        { proportion: 6, widgets: [{ id: "tasks", type: "cf.platform.embeddedSearchAsTable", config: { height: 400, search: '{"filters":[{"typeNames":["cf.project.Task"]}]}' } }] },
+        { proportion: 6, widgets: [{ id: "milestones", type: "cf.platform.embeddedSearchAsTable", config: { height: 400, search: '{"filters":[{"typeNames":["cf.project.Milestone"]}]}' } }] }
+      ]
+    },
+    { columns: [{ proportion: 12, widgets: [{ id: "comments", type: "cf.platform.comments" }] }] }
+  ]
+});
+
+Widget with embedded layout (container widget):
+layout.define({
+  rows: [
+    {
+      columns: [
+        {
+          proportion: 12,
+          widgets: [
+            {
+              type: "cf.platform.attributesGroup",
+              config: { title: "Details Section" },
+              embeddedLayouts: {
+                "widgetsLayout": {
+                  rows: [
+                    {
+                      columns: [
+                        { proportion: 6, widgets: [{ type: "cf.platform.wiki" }] },
+                        { proportion: 6, widgets: [{ type: "cf.platform.files" }] }
+                      ]
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+});
+
+Dynamic layout using search APIs:
+var search = new Search();
+search.add(Filters.type("cf.project.Dashboard"));
+var count = search.getResultCount();
+var widgets = [{ type: "cf.platform.wiki", config: { title: "Summary (" + count + " dashboards)" } }];
+if (count > 0) {
+  widgets.push({ type: "cf.platform.embeddedSearchAsTable", config: { height: 400, search: '{"filters":[{"typeNames":["cf.project.Dashboard"]}]}' } });
+}
+layout.define({ rows: [{ columns: [{ proportion: 12, widgets: widgets }] }] });`)
+        },
+        annotations: { title: "Execute Layout Script" }
+    },
+    [TOOL_LAYOUT_GET_OVERVIEW]: {
+        description: "Get layout structure for page or type. Provides an overview of the layout grid including rows, columns, and widget summaries for both page and type layouts.",
+        inputSchema: {
+            context: LayoutContextSchema
+        },
+        annotations: { title: "Get Layout Overview" }
+    },
+    [TOOL_LAYOUT_GET_WIDGET_DETAILS]: {
+        description: "Get detailed widget configuration from page or type layout. Extracts specific widget information from the layout structure.",
+        inputSchema: {
+            context: LayoutContextSchema,
+            widgetId: z.string().describe("The unique widget identifier to get details for")
+        },
+        annotations: { title: "Get Widget Details from Layout" }
+    },
+    [TOOL_LAYOUT_GET_SCRIPT]: {
+        description: `Get the current layout as a layout.define() JavaScript script for a page or type layout.
+
+WHEN TO USE:
+- To read the current layout before modifying it (read-edit-write workflow)
+- To inspect the full layout definition including widget configurations and embedded layouts
+- To copy a layout from one page/type to another
+
+RETURNS:
+- The layout as a layout.define({...}) script string, ready to be modified and posted back via cplace_layout_script
+- Widget config values are in the INPUT format accepted by cplace_layout_script (references as UID strings, rich strings as markup strings, localized strings as {locale: value} maps)
+
+ROUND-TRIP WORKFLOW:
+1. GET: Use this tool to retrieve the current layout script
+2. EDIT: Modify the script as needed
+3. POST: Use cplace_layout_script to apply the modified script`,
+        inputSchema: {
+            context: LayoutContextSchema
+        },
+        annotations: { title: "Get Layout Script" }
+    }
+};
+function determineApiEndpoint(context) {
+    return context.type === "page" ? "json/pageLayout" : "json/typeLayout";
+}
+function buildRequestParams(context) {
+    if (context.type === "page") {
+        return { pageUID: context.pageUID };
+    }
+    else {
+        return {
+            workspaceId: context.workspaceId,
+            typeInternalName: context.typeInternalName,
+            ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName })
+        };
+    }
+}
+async function getLayoutOverview(client, context) {
+    const endpoint = determineApiEndpoint(context);
+    const requestParams = buildRequestParams(context);
+    debugLogWithTag('LAYOUT', `getOverview operation on ${context.type} layout via ${endpoint}`);
+    return await client.makeApiRequest(endpoint, 'GET', requestParams);
+}
+export function registerLayoutScriptTools(server, client) {
+    server.registerTool(TOOL_LAYOUT_SCRIPT, LAYOUT_SCRIPT_TOOL_DEFINITIONS[TOOL_LAYOUT_SCRIPT], async ({ context, script }) => {
+        debugLogWithTag('LAYOUT_SCRIPT', `Executing layout script for ${context.type} layout (${script.length} chars)`);
+        try {
+            const endpoint = context.type === "page"
+                ? "json/page/layoutScript"
+                : "json/type/layoutScript";
+            let requestBody;
+            if (context.type === "page") {
+                requestBody = {
+                    pageUID: context.pageUID,
+                    script
+                };
+            }
+            else {
+                requestBody = {
+                    workspaceId: context.workspaceId,
+                    typeInternalName: context.typeInternalName,
+                    ...(context.alternativeLayoutName && { alternativeLayoutName: context.alternativeLayoutName }),
+                    script
+                };
+            }
+            const rawResponse = await client.makeRawApiRequest(endpoint, 'POST', undefined, requestBody);
+            debugLogWithTag('LAYOUT_SCRIPT', `Raw response success: ${rawResponse.success}, status: ${rawResponse.status || 'N/A'}`);
+            let response;
+            if (rawResponse.success === true) {
+                response = {
+                    operation: "LAYOUT_SCRIPT",
+                    success: true,
+                    status: rawResponse.status,
+                    context,
+                    result: rawResponse.result,
+                    ...(rawResponse.validationWarnings && { validationWarnings: rawResponse.validationWarnings })
+                };
+            }
+            else if (rawResponse.errors) {
+                response = {
+                    operation: "LAYOUT_SCRIPT",
+                    success: false,
+                    status: "VALIDATION_ERROR",
+                    context,
+                    errors: rawResponse.errors
+                };
+            }
+            else {
+                response = {
+                    operation: "LAYOUT_SCRIPT",
+                    success: false,
+                    status: "ERROR",
+                    context,
+                    errorMessage: rawResponse.errorMessage || "Unknown error"
+                };
+            }
+            const sizeCheck = checkResponseSize(response);
+            if (sizeCheck.tooLarge) {
+                if (response.result) {
+                    delete response.result;
+                    response.resultNote = "Layout was persisted successfully. Result omitted due to size. Use cplace_layout_get_overview to inspect.";
+                    const sizeCheck2 = checkResponseSize(response);
+                    if (sizeCheck2.tooLarge) {
+                        debugLogWithTag('LAYOUT_SCRIPT', `Response still too large after stripping result: ${sizeCheck2.actualSize} chars`);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Layout script response too large (${sizeCheck2.actualSize} characters) even after stripping result. Use cplace_layout_get_overview to inspect the layout.`
+                                }],
+                            isError: true
+                        };
+                    }
+                }
+                else {
+                    debugLogWithTag('LAYOUT_SCRIPT', `Error response too large: ${sizeCheck.actualSize} chars`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Layout script response too large (${sizeCheck.actualSize} characters). Use cplace_layout_get_overview to inspect the layout.`
+                            }],
+                        isError: true
+                    };
+                }
+            }
+            debugLogWithTag('LAYOUT_SCRIPT', `Returning response with success=${response.success}, status=${response.status}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+                ...(!response.success ? { isError: true } : {})
+            };
+        }
+        catch (error) {
+            debugLogWithTag('LAYOUT_SCRIPT', `Error: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error executing layout script: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_LAYOUT_GET_OVERVIEW, LAYOUT_SCRIPT_TOOL_DEFINITIONS[TOOL_LAYOUT_GET_OVERVIEW], async ({ context }) => {
+        debugLogWithTag('LAYOUT', `Starting layout overview request for ${context.type} layout`);
+        try {
+            const result = await getLayoutOverview(client, context);
+            const overview = {
+                context,
+                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,
+                            validationStatus: widget.validationStatus || null
+                        })) || []
+                    })) || []
+                })) || []
+            };
+            debugLogWithTag('LAYOUT', `Retrieved ${context.type} layout overview successfully`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(overview, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('LAYOUT', `Error getting layout overview: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting ${context.type} layout overview: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_LAYOUT_GET_WIDGET_DETAILS, LAYOUT_SCRIPT_TOOL_DEFINITIONS[TOOL_LAYOUT_GET_WIDGET_DETAILS], async ({ context, widgetId }) => {
+        debugLogWithTag('LAYOUT', `Getting widget details for ${widgetId} from ${context.type} layout`);
+        try {
+            const layoutResult = await getLayoutOverview(client, context);
+            let foundWidget = null;
+            const findWidget = (rows) => {
+                for (const row of rows || []) {
+                    for (const column of row.columns || []) {
+                        for (const widget of column.widgets || []) {
+                            if (widget.id === widgetId) {
+                                return widget;
+                            }
+                            if (widget.widgetsLayout?.rows) {
+                                const nestedWidget = findWidget(widget.widgetsLayout.rows);
+                                if (nestedWidget)
+                                    return nestedWidget;
+                            }
+                        }
+                    }
+                }
+                return null;
+            };
+            foundWidget = findWidget(layoutResult.rows);
+            if (!foundWidget) {
+                return {
+                    content: [{ type: "text", text: `Widget with ID ${widgetId} not found in ${context.type} layout` }]
+                };
+            }
+            debugLogWithTag('LAYOUT', `Retrieved widget details for: ${widgetId} from ${context.type} layout`);
+            const response = {
+                context,
+                widgetId,
+                widget: foundWidget,
+                validationStatus: foundWidget.validationStatus || null
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('LAYOUT', `Error getting widget details: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting widget details from ${context.type} layout: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_LAYOUT_GET_SCRIPT, LAYOUT_SCRIPT_TOOL_DEFINITIONS[TOOL_LAYOUT_GET_SCRIPT], async ({ context }) => {
+        debugLogWithTag('LAYOUT', `Getting layout script for ${context.type} layout`);
+        try {
+            const endpoint = context.type === "page"
+                ? "json/page/layoutScript"
+                : "json/type/layoutScript";
+            const params = buildRequestParams(context);
+            const rawResponse = await client.makeRawApiRequest(endpoint, 'GET', params);
+            if (rawResponse.success !== true) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error getting ${context.type} layout script: ${rawResponse.errorMessage || "Unknown error"}`
+                        }],
+                    isError: true
+                };
+            }
+            const response = {
+                context,
+                script: rawResponse.script
+            };
+            const sizeCheck = checkResponseSize(response);
+            if (sizeCheck.tooLarge) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Layout script response too large (${sizeCheck.actualSize} characters). Use cplace_layout_get_overview to inspect the layout structure instead.`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+            };
+        }
+        catch (error) {
+            debugLogWithTag('LAYOUT', `Error getting layout script: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting ${context.type} layout script: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+}
+//# sourceMappingURL=layout-script.js.map