@cplace/mcp-server 1.6.2 → 1.7.1

package/dist/tools/wizards.js

@@ -0,0 +1,798 @@
+import { z } from "zod";
+import { debugLogWithTag } from "../logger.js";
+import { checkResponseSize } from "../utils.js";
+function stripPagePrefix(uid) {
+    return uid.startsWith('page/') ? uid.substring(5) : uid;
+}
+const TOOL_MANAGE_WIZARD = 'cplace_manage_wizard';
+const TOOL_MANAGE_WIZARD_STEP = 'cplace_manage_wizard_step';
+const TOOL_DELETE_WIZARD = 'cplace_delete_wizard';
+const TOOL_DELETE_WIZARD_STEP = 'cplace_delete_wizard_step';
+const TOOL_CONFIGURE_WIZARD_FLOW = 'cplace_configure_wizard_flow';
+const TOOL_ACTIVATE_WIZARD = 'cplace_activate_wizard';
+const TOOL_GET_WIZARD_DETAILS = 'cplace_get_wizard_details';
+const TOOL_LIST_WIZARDS = 'cplace_list_wizards';
+const TOOL_ANALYZE_WIZARD = 'cplace_analyze_wizard';
+const TOOL_GET_WIZARD_ACTIVATION_STATE = 'cplace_get_wizard_activation_state';
+const WIZARD_TYPE = 'cf.cplace.formsWizard.wizard';
+const ATTR_PREFIX = 'cf.cplace.formsWizard';
+const STEP_TYPE = `${ATTR_PREFIX}.step`;
+const STEP_TYPE_ENUM = {
+    form: `${ATTR_PREFIX}.form`,
+    info: `${ATTR_PREFIX}.info`,
+    table: `${ATTR_PREFIX}.table`,
+    decision: `${ATTR_PREFIX}.decision`,
+    script: `${ATTR_PREFIX}.script`,
+};
+const VALID_STEP_TYPES = Object.keys(STEP_TYPE_ENUM);
+const WIZARD_ATTR = {
+    displayName: `${ATTR_PREFIX}.name`,
+    description: `${ATTR_PREFIX}.description`,
+    targetWorkspaces: `${ATTR_PREFIX}.targetWorkspaces`,
+    triggeringTypes: `${ATTR_PREFIX}.triggerTypes`,
+    autoPersist: `${ATTR_PREFIX}.autoPersist`,
+    refreshAfterFinish: `${ATTR_PREFIX}.refreshEmbeddingPageAfterFinish`,
+    showProgressBar: `${ATTR_PREFIX}.showProgressBar`,
+    showPercent: `${ATTR_PREFIX}.showPercentInProgressBar`,
+    startStep: `${ATTR_PREFIX}.startStep`,
+    finalSteps: `${ATTR_PREFIX}.finalSteps`,
+    summaryStep: `${ATTR_PREFIX}.summary`,
+    cleanupScriptStep: `${ATTR_PREFIX}.cleanupScript`,
+};
+const STEP_ATTR = {
+    wizardRef: `${ATTR_PREFIX}.wizard`,
+    identifier: `${ATTR_PREFIX}.identifier`,
+    title: `${ATTR_PREFIX}.title`,
+    description: `${ATTR_PREFIX}.description`,
+    stepType: `${ATTR_PREFIX}.stepType`,
+    configurationReference: `${ATTR_PREFIX}.configurationReference`,
+    nextPossibleSteps: `${ATTR_PREFIX}.next`,
+    skipTo: `${ATTR_PREFIX}.skipto`,
+    skipToFinish: `${ATTR_PREFIX}.skiptoFinish`,
+    skipToLabel: `${ATTR_PREFIX}.skiptoLabel`,
+    targetTypes: `${ATTR_PREFIX}.targetTypes`,
+};
+const FORM_CONFIG_TYPE = `${ATTR_PREFIX}.step.form.configuration`;
+const FORM_CONFIG_ATTR = {
+    typeNameToAttributesMapping: `${FORM_CONFIG_TYPE}.typeNameToAttributesMapping`,
+    layout: `${FORM_CONFIG_TYPE}.layout`,
+    isOneColumnLayout: `${FORM_CONFIG_TYPE}.isOneColumnLayout`,
+    stepRef: `${ATTR_PREFIX}.stepConfiguration.step`,
+};
+async function resolveWizard(client, workspaceId, wizardName) {
+    debugLogWithTag('WIZARD_RESOLVE', `Resolving wizard '${wizardName}' in workspace '${workspaceId}'`);
+    const cplaceFilter = {
+        filters: [
+            { type: "Type", types: [WIZARD_TYPE] },
+            { type: "Workspace", workspaceIds: [workspaceId] },
+            { type: "BuiltinAttributeValue", attribute: "name", operator: "equals", string: wizardName }
+        ]
+    };
+    const searchResult = await client.makeApiRequest('json/search', 'GET', {
+        filter: JSON.stringify(cplaceFilter)
+    });
+    const pages = searchResult?.results || [];
+    if (pages.length === 0) {
+        throw new Error(`Wizard '${wizardName}' not found in workspace '${workspaceId}'`);
+    }
+    if (pages.length > 1) {
+        throw new Error(`Multiple wizards named '${wizardName}' found in workspace '${workspaceId}'. Use a unique name.`);
+    }
+    const wizard = pages[0];
+    return { uid: wizard.uid || wizard.id, name: wizardName };
+}
+async function resolveWizardWithSteps(client, workspaceId, wizardName) {
+    const wizard = await resolveWizard(client, workspaceId, wizardName);
+    debugLogWithTag('WIZARD_RESOLVE', `Resolving steps for wizard '${wizardName}' (${wizard.uid})`);
+    const stepFilter = {
+        filters: [
+            { type: "Type", types: [STEP_TYPE] },
+            { type: "Workspace", workspaceIds: [workspaceId] },
+            { type: "CustomAttributeValue", attribute: STEP_ATTR.wizardRef, operator: "equals", reference: wizard.uid }
+        ]
+    };
+    const searchResult = await client.makeApiRequest('json/search', 'GET', {
+        filter: JSON.stringify(stepFilter)
+    });
+    const stepPages = searchResult?.results || [];
+    const steps = new Map();
+    for (const step of stepPages) {
+        const attrs = step.attributes || step.customAttributes || {};
+        const identifier = attrs[STEP_ATTR.identifier] || attrs['cf.cplace.formsWizard.identifier'] || step.name;
+        if (identifier) {
+            steps.set(identifier, step.uid || step.id);
+        }
+    }
+    debugLogWithTag('WIZARD_RESOLVE', `Resolved ${steps.size} steps for wizard '${wizardName}'`);
+    return { wizard, steps };
+}
+async function resolveTypeInternalNames(client, workspaceId, typeInternalNames) {
+    const resolvedUids = [];
+    for (const internalName of typeInternalNames) {
+        debugLogWithTag('WIZARD_RESOLVE', `Resolving type '${internalName}' in workspace '${workspaceId}'`);
+        const result = await client.makeApiRequest('json/type-definition', 'GET', {
+            workspaceId,
+            internalName
+        });
+        const uid = result.uid;
+        if (!uid) {
+            throw new Error(`Type '${internalName}' not found in workspace '${workspaceId}'`);
+        }
+        resolvedUids.push(uid.startsWith('typeDefinition/') ? uid : `typeDefinition/${uid}`);
+    }
+    return resolvedUids;
+}
+function enhanceWizardError(errorMessage) {
+    if (errorMessage.includes('cf.cplace.formsWizard') && (errorMessage.includes('not found') ||
+        errorMessage.includes('Type definition not found') ||
+        errorMessage.includes('Ungültiger Wert'))) {
+        return `${errorMessage}\nHint: The Forms Wizard app may not be installed in this workspace. Use cplace_install_workspace_app with qualifiedName 'cf.cplace.formsWizard' to install it.`;
+    }
+    return errorMessage;
+}
+async function configureFormStepAttributes(client, configPageUid, formAttributes) {
+    const typeNameToAttributesMapping = JSON.stringify(formAttributes);
+    const layout = [];
+    for (const [typeName, attrs] of Object.entries(formAttributes)) {
+        for (const attr of attrs) {
+            layout.push({ type: 'attribute', typeName, attributeName: attr });
+        }
+    }
+    debugLogWithTag('WIZARD_STEP', `Configuring form attributes on config page ${configPageUid}: ${typeNameToAttributesMapping}`);
+    await client.makeApiRequest('json/page', 'PATCH', undefined, {
+        pageUID: configPageUid,
+        attributes: {
+            [FORM_CONFIG_ATTR.typeNameToAttributesMapping]: typeNameToAttributesMapping,
+            [FORM_CONFIG_ATTR.layout]: JSON.stringify(layout),
+        }
+    });
+}
+function resolveStepTypeEnum(stepType) {
+    const enumValue = STEP_TYPE_ENUM[stepType];
+    if (!enumValue) {
+        throw new Error(`Unknown step type '${stepType}'. Valid types: ${VALID_STEP_TYPES.join(', ')}`);
+    }
+    return enumValue;
+}
+function extractWizardSummary(page) {
+    const attrs = page.attributes || {};
+    const summary = {};
+    if (attrs[WIZARD_ATTR.displayName])
+        summary.displayName = attrs[WIZARD_ATTR.displayName];
+    if (attrs[WIZARD_ATTR.description])
+        summary.description = attrs[WIZARD_ATTR.description];
+    if (attrs[WIZARD_ATTR.autoPersist] !== undefined)
+        summary.autoPersist = attrs[WIZARD_ATTR.autoPersist];
+    if (attrs[WIZARD_ATTR.refreshAfterFinish] !== undefined)
+        summary.refreshAfterFinish = attrs[WIZARD_ATTR.refreshAfterFinish];
+    if (attrs[WIZARD_ATTR.showProgressBar] !== undefined)
+        summary.showProgressBar = attrs[WIZARD_ATTR.showProgressBar];
+    if (attrs[WIZARD_ATTR.showPercent] !== undefined)
+        summary.showPercent = attrs[WIZARD_ATTR.showPercent];
+    if (attrs[WIZARD_ATTR.startStep])
+        summary.startStep = attrs[WIZARD_ATTR.startStep];
+    if (attrs[WIZARD_ATTR.finalSteps])
+        summary.finalSteps = attrs[WIZARD_ATTR.finalSteps];
+    if (attrs[WIZARD_ATTR.summaryStep])
+        summary.summaryStep = attrs[WIZARD_ATTR.summaryStep];
+    if (attrs[WIZARD_ATTR.targetWorkspaces])
+        summary.targetWorkspaces = attrs[WIZARD_ATTR.targetWorkspaces];
+    if (attrs[WIZARD_ATTR.triggeringTypes])
+        summary.triggeringTypes = attrs[WIZARD_ATTR.triggeringTypes];
+    return summary;
+}
+function extractStepSummary(page) {
+    const attrs = page.attributes || {};
+    const summary = {};
+    if (attrs[STEP_ATTR.stepType])
+        summary.stepType = attrs[STEP_ATTR.stepType];
+    if (attrs[STEP_ATTR.title])
+        summary.title = attrs[STEP_ATTR.title];
+    if (attrs[STEP_ATTR.description])
+        summary.description = attrs[STEP_ATTR.description];
+    if (attrs[STEP_ATTR.nextPossibleSteps])
+        summary.nextPossibleSteps = attrs[STEP_ATTR.nextPossibleSteps];
+    if (attrs[STEP_ATTR.skipTo])
+        summary.skipTo = attrs[STEP_ATTR.skipTo];
+    if (attrs[STEP_ATTR.skipToFinish] !== undefined)
+        summary.skipToFinish = attrs[STEP_ATTR.skipToFinish];
+    if (attrs[STEP_ATTR.targetTypes])
+        summary.targetTypes = attrs[STEP_ATTR.targetTypes];
+    return summary;
+}
+function extractWizardListSummary(page) {
+    const attrs = page.attributes || {};
+    const summary = {};
+    if (attrs[WIZARD_ATTR.displayName])
+        summary.displayName = attrs[WIZARD_ATTR.displayName];
+    if (attrs[WIZARD_ATTR.startStep])
+        summary.hasStartStep = true;
+    return summary;
+}
+export const WIZARD_TOOL_DEFINITIONS = {
+    [TOOL_MANAGE_WIZARD]: {
+        description: "Create or update a Forms Wizard configuration. Wizards define multi-step guided workflows for data entry and process automation. Use 'create' to define a new wizard with display names, target workspaces, and behavior options. Use 'update' to modify an existing wizard's properties.",
+        inputSchema: {
+            operation: z.enum(["create", "update"]).describe("Operation type: 'create' for new wizards, 'update' for existing wizards"),
+            workspaceId: z.string().describe("The workspace ID where the wizard lives (e.g., 'iwu7z9iscgr0')"),
+            wizardName: z.string().describe("For create: the name to give the wizard. For update: identifies the wizard to modify."),
+            localizedDisplayNames: z.record(z.string()).optional().describe("Localized display names (e.g., {\"en\": \"My Wizard\", \"de\": \"Mein Assistent\"})"),
+            description: z.string().optional().describe("Wizard description text"),
+            targetWorkspaces: z.array(z.string()).optional().describe("Workspace IDs where the wizard can be used"),
+            triggeringTypes: z.array(z.string()).optional().describe("Type internal names that trigger this wizard (e.g., ['cf.example.Task'])"),
+            autoPersist: z.boolean().optional().describe("Auto-persist changes after each step (default: false)"),
+            refreshAfterFinish: z.boolean().optional().describe("Refresh page after wizard finishes (default: false)"),
+            showProgressBar: z.boolean().optional().describe("Show progress bar during wizard execution"),
+            showPercent: z.boolean().optional().describe("Show percentage in progress bar"),
+        },
+        annotations: { title: "Manage Wizard" }
+    },
+    [TOOL_MANAGE_WIZARD_STEP]: {
+        description: "Create or update a wizard step. Steps are the individual screens in a wizard flow. Each step has a type (form, info, table, decision, script) that determines its behavior and configuration options. Step type is immutable after creation.",
+        inputSchema: {
+            operation: z.enum(["create", "update"]).describe("Operation type: 'create' for new steps, 'update' for existing steps"),
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the parent wizard"),
+            identifier: z.string().describe("Unique step identifier (e.g., 'step-enter-details')"),
+            stepType: z.enum(["form", "info", "table", "decision", "script"]).optional().describe("Step type — required for create, rejected for update (immutable). Types: form (data entry), info (display content), table (search/select), decision (branching), script (automation)"),
+            title: z.record(z.string()).optional().describe("Localized step title (e.g., {\"en\": \"Enter Details\", \"de\": \"Details eingeben\"})"),
+            description: z.string().optional().describe("Step description (rich text/HTML)"),
+            targetTypes: z.array(z.string()).optional().describe("Form step: type internal names for data entry targets"),
+            formAttributes: z.record(z.array(z.string())).optional().describe("Form step: map of target type names to attribute arrays to display in the form. IMPORTANT: builtin attributes (e.g., \"name\") use bare identifiers, while custom attributes must be wrapped in single quotes (e.g., \"'test.parentProject'\"). Example: {\"test.project\": [\"name\", \"'test.parentProject'\", \"'test.managers'\"]}. Automatically configures the form step's child configuration page."),
+        },
+        annotations: { title: "Manage Wizard Step" }
+    },
+    [TOOL_DELETE_WIZARD]: {
+        description: "Delete a wizard and optionally all its child steps. By default, cascade-deletes all steps. Set cascadeDeleteSteps to false to delete only the wizard page.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the wizard to delete"),
+            cascadeDeleteSteps: z.boolean().optional().default(true).describe("Delete all child steps too (default: true)"),
+        },
+        annotations: { title: "Delete Wizard" }
+    },
+    [TOOL_DELETE_WIZARD_STEP]: {
+        description: "Delete a single wizard step by its identifier. The step is removed from the wizard; any flow references to this step should be updated separately.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the parent wizard"),
+            identifier: z.string().describe("The identifier of the step to delete"),
+        },
+        annotations: { title: "Delete Wizard Step" }
+    },
+    [TOOL_CONFIGURE_WIZARD_FLOW]: {
+        description: "Configure the complete step flow graph for a wizard in a single call. Sets the start step, final steps, optional summary/cleanup steps, and all step-to-step connections. All referenced step identifiers must already exist.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the wizard to configure"),
+            startStep: z.string().describe("Identifier of the start step"),
+            finalSteps: z.array(z.string()).describe("Identifiers of final steps (wizard ends after these)"),
+            summaryStep: z.string().optional().describe("Identifier of the summary step (shown before finish)"),
+            cleanupScriptStep: z.string().optional().describe("Identifier of the cleanup script step (runs on finish)"),
+            stepConnections: z.array(z.object({
+                from: z.string().describe("Step identifier for the source step"),
+                nextSteps: z.array(z.string()).describe("Step identifiers for the next possible steps"),
+                skipTo: z.string().optional().describe("Step identifier to skip to"),
+                skipToFinish: z.boolean().optional().describe("Allow skipping to finish from this step"),
+                skipToLabel: z.record(z.string()).optional().describe("Localized label for skip-to button"),
+            })).describe("Connections between steps defining the flow graph"),
+        },
+        annotations: { title: "Configure Wizard Flow" }
+    },
+    [TOOL_ACTIVATE_WIZARD]: {
+        description: "Activate or deactivate a wizard. On activation, runs the server-side analysis check (validates start step, final steps, step reachability, etc.). If activation fails, automatically runs analysis and returns detailed error information.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the wizard to activate"),
+            activationState: z.enum(['ACTIVE', 'INACTIVE']).optional().describe("Target activation state (default: 'ACTIVE')"),
+        },
+        annotations: { title: "Activate Wizard" }
+    },
+    [TOOL_GET_WIZARD_DETAILS]: {
+        description: "Get detailed information about a wizard including all its steps, flow configuration, and activation state. Returns structured wizard-domain data with step identifiers, types, and connections.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard lives"),
+            wizardName: z.string().describe("Name of the wizard to inspect"),
+        },
+        annotations: { title: "Get Wizard Details" }
+    },
+    [TOOL_LIST_WIZARDS]: {
+        description: "List all wizards in a workspace. Returns wizard names, display names, and basic configuration summary.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID to search for wizards"),
+        },
+        annotations: { title: "List Wizards" }
+    },
+    [TOOL_ANALYZE_WIZARD]: {
+        description: "Run the wizard analysis checks without changing activation state. Returns results from all wizard-level analyzers (start step, step reachability, final steps, leaf nodes, skip configuration, external access) plus per-step type-specific analysis. Use this to validate wizard configuration before activation or to debug why activation fails.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard exists"),
+            wizardName: z.string().describe("The name of the wizard to analyze"),
+        },
+        annotations: { title: "Analyze Wizard Configuration" }
+    },
+    [TOOL_GET_WIZARD_ACTIVATION_STATE]: {
+        description: "Get the current activation state of a wizard without changing it. Returns whether the wizard is ACTIVE or INACTIVE, and whether the state can be changed. Use this for pre-flight checks before activation, or to monitor wizard states across workspaces.",
+        inputSchema: {
+            workspaceId: z.string().describe("The workspace ID where the wizard exists"),
+            wizardName: z.string().describe("The name of the wizard to check"),
+        },
+        annotations: { title: "Get Wizard Activation State" }
+    },
+};
+export function registerWizardTools(server, client) {
+    server.registerTool(TOOL_MANAGE_WIZARD, WIZARD_TOOL_DEFINITIONS[TOOL_MANAGE_WIZARD], async (params) => {
+        try {
+            if (params.operation === "create") {
+                const requestBody = {
+                    workspaceId: params.workspaceId,
+                    typeInternalName: WIZARD_TYPE,
+                    name: params.wizardName,
+                };
+                const attributes = {};
+                if (params.localizedDisplayNames)
+                    attributes[WIZARD_ATTR.displayName] = params.localizedDisplayNames;
+                if (params.description)
+                    attributes[WIZARD_ATTR.description] = params.description;
+                if (params.targetWorkspaces)
+                    attributes[WIZARD_ATTR.targetWorkspaces] = params.targetWorkspaces;
+                if (params.triggeringTypes)
+                    attributes[WIZARD_ATTR.triggeringTypes] = await resolveTypeInternalNames(client, params.workspaceId, params.triggeringTypes);
+                if (params.autoPersist !== undefined)
+                    attributes[WIZARD_ATTR.autoPersist] = params.autoPersist;
+                if (params.refreshAfterFinish !== undefined)
+                    attributes[WIZARD_ATTR.refreshAfterFinish] = params.refreshAfterFinish;
+                if (params.showProgressBar !== undefined)
+                    attributes[WIZARD_ATTR.showProgressBar] = params.showProgressBar;
+                if (params.showPercent !== undefined)
+                    attributes[WIZARD_ATTR.showPercent] = params.showPercent;
+                if (Object.keys(attributes).length > 0)
+                    requestBody.attributes = attributes;
+                debugLogWithTag('WIZARD_MANAGE', `Creating wizard '${params.wizardName}' in workspace '${params.workspaceId}'`);
+                const result = await client.makeApiRequest('json/page/create', 'POST', undefined, requestBody);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            }
+            else {
+                const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+                const requestBody = { pageUID: resolved.uid };
+                const attributes = {};
+                if (params.localizedDisplayNames !== undefined)
+                    attributes[WIZARD_ATTR.displayName] = params.localizedDisplayNames;
+                if (params.description !== undefined)
+                    attributes[WIZARD_ATTR.description] = params.description;
+                if (params.targetWorkspaces !== undefined)
+                    attributes[WIZARD_ATTR.targetWorkspaces] = params.targetWorkspaces;
+                if (params.triggeringTypes !== undefined) {
+                    attributes[WIZARD_ATTR.triggeringTypes] = params.triggeringTypes.length > 0
+                        ? await resolveTypeInternalNames(client, params.workspaceId, params.triggeringTypes)
+                        : params.triggeringTypes;
+                }
+                if (params.autoPersist !== undefined)
+                    attributes[WIZARD_ATTR.autoPersist] = params.autoPersist;
+                if (params.refreshAfterFinish !== undefined)
+                    attributes[WIZARD_ATTR.refreshAfterFinish] = params.refreshAfterFinish;
+                if (params.showProgressBar !== undefined)
+                    attributes[WIZARD_ATTR.showProgressBar] = params.showProgressBar;
+                if (params.showPercent !== undefined)
+                    attributes[WIZARD_ATTR.showPercent] = params.showPercent;
+                if (Object.keys(attributes).length > 0) {
+                    requestBody.attributes = attributes;
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: "No updates specified." }],
+                        isError: true
+                    };
+                }
+                debugLogWithTag('WIZARD_MANAGE', `Updating wizard '${params.wizardName}' (${resolved.uid})`);
+                const result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            }
+        }
+        catch (error) {
+            const operationText = params.operation === "create" ? "creating" : "updating";
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error ${operationText} wizard: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_MANAGE_WIZARD_STEP, WIZARD_TOOL_DEFINITIONS[TOOL_MANAGE_WIZARD_STEP], async (params) => {
+        try {
+            if (params.operation === "create") {
+                if (!params.stepType) {
+                    return {
+                        content: [{ type: "text", text: "Error: stepType is required for create operation" }],
+                        isError: true
+                    };
+                }
+                const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+                const stepTypeEnum = resolveStepTypeEnum(params.stepType);
+                const requestBody = {
+                    workspaceId: params.workspaceId,
+                    typeInternalName: STEP_TYPE,
+                    parentUID: resolved.uid,
+                    name: params.identifier,
+                };
+                const attributes = {};
+                attributes[STEP_ATTR.identifier] = params.identifier;
+                attributes[STEP_ATTR.stepType] = stepTypeEnum;
+                attributes[STEP_ATTR.wizardRef] = resolved.uid;
+                if (params.title)
+                    attributes[STEP_ATTR.title] = params.title;
+                if (params.description)
+                    attributes[STEP_ATTR.description] = params.description;
+                if (params.targetTypes)
+                    attributes[STEP_ATTR.targetTypes] = await resolveTypeInternalNames(client, params.workspaceId, params.targetTypes);
+                requestBody.attributes = attributes;
+                debugLogWithTag('WIZARD_STEP', `Creating ${params.stepType} step '${params.identifier}' under wizard '${params.wizardName}'`);
+                const result = await client.makeApiRequest('json/page/create', 'POST', undefined, requestBody);
+                if (params.formAttributes && params.stepType === 'form') {
+                    const configChild = result?.children?.find((c) => c.type?.internalName === FORM_CONFIG_TYPE);
+                    if (configChild) {
+                        const configUid = configChild.uid || configChild.id;
+                        await configureFormStepAttributes(client, configUid, params.formAttributes);
+                        debugLogWithTag('WIZARD_STEP', `Configured form attributes on ${configUid}`);
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            }
+            else {
+                if (params.stepType !== undefined) {
+                    return {
+                        content: [{ type: "text", text: "Error: stepType is immutable after creation. Create a new step instead." }],
+                        isError: true
+                    };
+                }
+                const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
+                const stepUid = resolved.steps.get(params.identifier);
+                if (!stepUid) {
+                    const available = Array.from(resolved.steps.keys()).join(', ');
+                    return {
+                        content: [{ type: "text", text: `Error: Step '${params.identifier}' not found. Available: ${available}` }],
+                        isError: true
+                    };
+                }
+                const requestBody = { pageUID: stepUid };
+                const attributes = {};
+                if (params.title !== undefined)
+                    attributes[STEP_ATTR.title] = params.title;
+                if (params.description !== undefined)
+                    attributes[STEP_ATTR.description] = params.description;
+                if (params.targetTypes !== undefined) {
+                    attributes[STEP_ATTR.targetTypes] = params.targetTypes.length > 0
+                        ? await resolveTypeInternalNames(client, params.workspaceId, params.targetTypes)
+                        : params.targetTypes;
+                }
+                if (Object.keys(attributes).length === 0 && !params.formAttributes) {
+                    return {
+                        content: [{ type: "text", text: "No updates specified." }],
+                        isError: true
+                    };
+                }
+                let result;
+                if (Object.keys(attributes).length > 0) {
+                    requestBody.attributes = attributes;
+                    debugLogWithTag('WIZARD_STEP', `Updating step '${params.identifier}' (${stepUid})`);
+                    result = await client.makeApiRequest('json/page', 'PATCH', undefined, requestBody);
+                }
+                else {
+                    result = await client.makeApiRequest('json/page', 'GET', { pageUID: stepUid });
+                }
+                if (params.formAttributes) {
+                    const configRef = result?.attributes?.[STEP_ATTR.configurationReference];
+                    const configUid = configRef?.uid || configRef;
+                    if (configUid) {
+                        await configureFormStepAttributes(client, configUid, params.formAttributes);
+                        debugLogWithTag('WIZARD_STEP', `Updated form attributes on ${configUid}`);
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            }
+        }
+        catch (error) {
+            const operationText = params.operation === "create" ? "creating" : "updating";
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error ${operationText} wizard step: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_DELETE_WIZARD, WIZARD_TOOL_DEFINITIONS[TOOL_DELETE_WIZARD], async (params) => {
+        try {
+            const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+            debugLogWithTag('WIZARD_DELETE', `Deleting wizard '${params.wizardName}' (${resolved.uid}), cascade: ${params.cascadeDeleteSteps}`);
+            if (params.cascadeDeleteSteps !== false) {
+                const result = await client.makeApiRequest('json/page/with-children', 'DELETE', undefined, {
+                    pageUID: resolved.uid,
+                    confirmDeleteChildren: true
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            }
+            else {
+                const result = await client.makeApiRequest('json/page', 'DELETE', { pageUID: resolved.uid });
+                return {
+                    content: [{ type: "text", text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) }]
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error deleting wizard: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_DELETE_WIZARD_STEP, WIZARD_TOOL_DEFINITIONS[TOOL_DELETE_WIZARD_STEP], async (params) => {
+        try {
+            const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
+            const stepUid = resolved.steps.get(params.identifier);
+            if (!stepUid) {
+                const available = Array.from(resolved.steps.keys()).join(', ');
+                return {
+                    content: [{ type: "text", text: `Error: Step '${params.identifier}' not found. Available: ${available}` }],
+                    isError: true
+                };
+            }
+            debugLogWithTag('WIZARD_STEP_DELETE', `Deleting step '${params.identifier}' (${stepUid})`);
+            const result = await client.makeApiRequest('json/page/with-children', 'DELETE', undefined, {
+                pageUID: stepUid,
+                confirmDeleteChildren: true
+            });
+            return {
+                content: [{ type: "text", text: typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error deleting wizard step: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_CONFIGURE_WIZARD_FLOW, WIZARD_TOOL_DEFINITIONS[TOOL_CONFIGURE_WIZARD_FLOW], async (params) => {
+        try {
+            const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
+            const allReferencedIds = new Set([
+                params.startStep,
+                ...params.finalSteps,
+                ...(params.summaryStep ? [params.summaryStep] : []),
+                ...(params.cleanupScriptStep ? [params.cleanupScriptStep] : []),
+                ...params.stepConnections.flatMap(c => [c.from, ...c.nextSteps, ...(c.skipTo ? [c.skipTo] : [])])
+            ]);
+            for (const id of allReferencedIds) {
+                if (!resolved.steps.has(id)) {
+                    return {
+                        content: [{ type: "text", text: `Error: Step '${id}' not found. Available: ${Array.from(resolved.steps.keys()).join(', ')}` }],
+                        isError: true
+                    };
+                }
+            }
+            debugLogWithTag('WIZARD_FLOW', `Configuring flow for wizard '${params.wizardName}' with ${params.stepConnections.length} connections`);
+            for (const conn of params.stepConnections) {
+                const stepUid = resolved.steps.get(conn.from);
+                const nextStepUids = conn.nextSteps.map(id => resolved.steps.get(id));
+                const attributes = {
+                    [STEP_ATTR.nextPossibleSteps]: nextStepUids
+                };
+                if (conn.skipTo)
+                    attributes[STEP_ATTR.skipTo] = resolved.steps.get(conn.skipTo);
+                if (conn.skipToFinish !== undefined)
+                    attributes[STEP_ATTR.skipToFinish] = conn.skipToFinish;
+                if (conn.skipToLabel)
+                    attributes[STEP_ATTR.skipToLabel] = conn.skipToLabel;
+                await client.makeApiRequest('json/page', 'PATCH', undefined, {
+                    pageUID: stepUid,
+                    attributes
+                });
+            }
+            const wizardAttributes = {
+                [WIZARD_ATTR.startStep]: resolved.steps.get(params.startStep),
+                [WIZARD_ATTR.finalSteps]: params.finalSteps.map(id => resolved.steps.get(id)),
+            };
+            if (params.summaryStep) {
+                wizardAttributes[WIZARD_ATTR.summaryStep] = resolved.steps.get(params.summaryStep);
+            }
+            if (params.cleanupScriptStep) {
+                wizardAttributes[WIZARD_ATTR.cleanupScriptStep] = resolved.steps.get(params.cleanupScriptStep);
+            }
+            await client.makeApiRequest('json/page', 'PATCH', undefined, {
+                pageUID: resolved.wizard.uid,
+                attributes: wizardAttributes
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            configured: true,
+                            wizardName: params.wizardName,
+                            stepCount: resolved.steps.size,
+                            connectionCount: params.stepConnections.length
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error configuring wizard flow: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_ACTIVATE_WIZARD, WIZARD_TOOL_DEFINITIONS[TOOL_ACTIVATE_WIZARD], async (params) => {
+        try {
+            const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+            debugLogWithTag('WIZARD_ACTIVATE', `Activating wizard '${params.wizardName}' (${resolved.uid})`);
+            const response = await client.makeApiRequest('json/wizard/activation', 'POST', undefined, { wizardId: stripPagePrefix(resolved.uid), activationState: params.activationState || 'ACTIVE' });
+            if (response?.activationState === 'ACTIVE' || response?.activationState === 'INACTIVE') {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                status: response.activationState === 'ACTIVE' ? 'activated' : 'deactivated',
+                                wizardName: params.wizardName,
+                                activationState: response.activationState,
+                                canChangeState: response.canChangeState
+                            }, null, 2) }]
+                };
+            }
+            else {
+                debugLogWithTag('WIZARD_ACTIVATE', `Activation failed, running analysis for wizard '${params.wizardName}'`);
+                let analysisResults = null;
+                try {
+                    analysisResults = await client.makeApiRequest('json/wizard/analysis', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+                }
+                catch (analysisError) {
+                    debugLogWithTag('WIZARD_ACTIVATE', `Auto-analysis also failed: ${analysisError}`);
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                status: 'failed',
+                                wizardName: params.wizardName,
+                                error: response || 'Activation failed — state was not changed',
+                                ...(analysisResults ? { analysisResults } : {})
+                            }, null, 2) }],
+                    isError: true
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: enhanceWizardError(`Error activating wizard: ${error instanceof Error ? error.message : String(error)}`) }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_GET_WIZARD_DETAILS, WIZARD_TOOL_DEFINITIONS[TOOL_GET_WIZARD_DETAILS], async (params) => {
+        try {
+            const resolved = await resolveWizardWithSteps(client, params.workspaceId, params.wizardName);
+            const wizardPage = await client.makeApiRequest('json/page', 'GET', { pageUID: resolved.wizard.uid });
+            const stepDetails = [];
+            for (const [identifier, uid] of resolved.steps) {
+                const stepPage = await client.makeApiRequest('json/page', 'GET', { pageUID: uid });
+                stepDetails.push({
+                    identifier,
+                    uid,
+                    name: stepPage.name,
+                    ...extractStepSummary(stepPage)
+                });
+            }
+            const result = {
+                wizardName: params.wizardName,
+                uid: resolved.wizard.uid,
+                ...extractWizardSummary(wizardPage),
+                steps: stepDetails
+            };
+            const sizeCheck = checkResponseSize(result);
+            if (sizeCheck.tooLarge) {
+                return {
+                    content: [{ type: "text", text: sizeCheck.suggestion }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting wizard details: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_LIST_WIZARDS, WIZARD_TOOL_DEFINITIONS[TOOL_LIST_WIZARDS], async (params) => {
+        try {
+            const listFilter = {
+                filters: [
+                    { type: "Type", types: [WIZARD_TYPE] },
+                    { type: "Workspace", workspaceIds: [params.workspaceId] }
+                ]
+            };
+            const searchResult = await client.makeApiRequest('json/search', 'GET', {
+                filter: JSON.stringify(listFilter)
+            });
+            const wizards = (searchResult?.results || []).map((page) => ({
+                name: page.name,
+                uid: page.uid || page.id,
+                ...extractWizardListSummary(page)
+            }));
+            const result = { wizards, count: wizards.length };
+            const sizeCheck = checkResponseSize(result);
+            if (sizeCheck.tooLarge) {
+                return {
+                    content: [{ type: "text", text: sizeCheck.suggestion }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error listing wizards: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_ANALYZE_WIZARD, WIZARD_TOOL_DEFINITIONS[TOOL_ANALYZE_WIZARD], async (params) => {
+        try {
+            const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+            debugLogWithTag('WIZARD_ANALYZE', `Analyzing wizard '${params.wizardName}' (${resolved.uid})`);
+            const response = await client.makeApiRequest('json/wizard/analysis', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+            const sizeCheck = checkResponseSize(response);
+            if (sizeCheck.tooLarge) {
+                return {
+                    content: [{ type: "text", text: sizeCheck.suggestion }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            wizardName: params.wizardName,
+                            analysisResults: response
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error analyzing wizard: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+    server.registerTool(TOOL_GET_WIZARD_ACTIVATION_STATE, WIZARD_TOOL_DEFINITIONS[TOOL_GET_WIZARD_ACTIVATION_STATE], async (params) => {
+        try {
+            const resolved = await resolveWizard(client, params.workspaceId, params.wizardName);
+            debugLogWithTag('WIZARD_ACTIVATION_STATE', `Getting activation state for wizard '${params.wizardName}' (${resolved.uid})`);
+            const response = await client.makeApiRequest('json/wizard/activation', 'GET', { wizardId: stripPagePrefix(resolved.uid) });
+            const sizeCheck = checkResponseSize(response);
+            if (sizeCheck.tooLarge) {
+                return {
+                    content: [{ type: "text", text: sizeCheck.suggestion }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            wizardName: params.wizardName,
+                            activationState: response.activationState,
+                            canChangeState: response.canChangeState
+                        }, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error getting wizard activation state: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true
+            };
+        }
+    });
+}
+//# sourceMappingURL=wizards.js.map