@enfyra/mcp-server 0.1.43 → 0.1.45

package/dist/lib/platform-operation-tools.js

@@ -19,6 +19,11 @@ const AUTO_INJECTED_EXTENSION_COMPONENT_TAGS = [
     'UFormField',
     'UIcon',
     'UInput',
+    'UInputMenu',
+    'UInputNumber',
+    'UInputTags',
+    'UInputTime',
+    'UInputDate',
     'UModal',
     'USelect',
     'USelectMenu',
@@ -30,6 +35,18 @@ const AUTO_INJECTED_EXTENSION_COMPONENT_TAGS = [
     'Widget',
 ];
 const AUTO_INJECTED_EXTENSION_COMPONENT_BY_LOWERCASE = new Map(AUTO_INJECTED_EXTENSION_COMPONENT_TAGS.map((tag) => [tag.toLowerCase(), tag]));
+const FULL_WIDTH_EXTENSION_FIELD_TAGS = [
+    'UInput',
+    'UTextarea',
+    'USelect',
+    'USelectMenu',
+    'UInputMenu',
+    'UInputNumber',
+    'UInputTags',
+    'UInputTime',
+    'UInputDate',
+];
+const FULL_WIDTH_EXTENSION_FIELD_PATTERN = new RegExp(`<(${FULL_WIDTH_EXTENSION_FIELD_TAGS.join('|')})(\\s[^<>]*?)(\\/?)>`, 'g');
 function unwrapData(result) {
     return Array.isArray(result?.data) ? result.data : [];
 }
@@ -308,7 +325,9 @@ function quoteJsString(value) {
 function normalizeVueBodySnippet(body) {
     let code = String(body || '').trim();
     const changes = [];
-    code = code.replace(/<(UInput|UTextarea|USelectMenu|USelect)(\s[^<>]*?)(\/?)>/g, (full, tag, attrs, slash) => {
+    code = code.replace(FULL_WIDTH_EXTENSION_FIELD_PATTERN, (full, tag, attrs, slash) => {
+        if (/\bdata-compact\b/.test(attrs) || /\bdata-inline\b/.test(attrs))
+            return full;
         if (/\bclass=/.test(attrs)) {
             const nextAttrs = attrs.replace(/class="([^"]*)"/, (classMatch, classes) => {
                 if (String(classes).split(/\s+/).includes('w-full'))
@@ -331,6 +350,23 @@ function normalizeVueBodySnippet(body) {
     });
     return { code, changes: Array.from(new Set(changes)) };
 }
+function findMissingFullWidthFieldControls(code) {
+    const violations = [];
+    for (const template of readTemplateBlocks(code)) {
+        let match;
+        FULL_WIDTH_EXTENSION_FIELD_PATTERN.lastIndex = 0;
+        while ((match = FULL_WIDTH_EXTENSION_FIELD_PATTERN.exec(template))) {
+            const [snippet, tag, attrs] = match;
+            if (/\bdata-compact\b/.test(attrs) || /\bdata-inline\b/.test(attrs))
+                continue;
+            const classMatch = attrs.match(/\bclass="([^"]*)"/);
+            if (!classMatch || !classMatch[1].split(/\s+/).includes('w-full')) {
+                violations.push({ tag, snippet: snippet.length > 160 ? `${snippet.slice(0, 157)}...` : snippet });
+            }
+        }
+    }
+    return violations;
+}
 function indentLines(code, spaces = 2) {
     const pad = ' '.repeat(spaces);
     return String(code || '')
@@ -473,6 +509,333 @@ export function buildExtensionModalSnippet(input) {
         ],
     };
 }
+function jsObjectLiteral(entries) {
+    return `{ ${entries.filter(Boolean).join(', ')} }`;
+}
+function jsArrayLiteral(values) {
+    return `[${(values || []).map(quoteJsString).join(', ')}]`;
+}
+function attrStaticOrBound(name, value, expression) {
+    if (expression)
+        return `:${name}="${expression}"`;
+    if (value === undefined || value === null || value === '')
+        return null;
+    return `${name}="${String(value).replace(/"/g, '&quot;')}"`;
+}
+function buildHeaderActionLiteral(action) {
+    const entries = [
+        action.id ? `id: ${quoteJsString(action.id)}` : null,
+        action.label ? `label: ${quoteJsString(action.label)}` : null,
+        action.icon ? `icon: ${quoteJsString(action.icon)}` : null,
+        `color: ${quoteJsString(action.color || 'neutral')}`,
+        `variant: ${quoteJsString(action.variant || 'outline')}`,
+        action.loading ? `loading: ${action.loading}` : null,
+        action.disabled ? `disabled: ${action.disabled}` : null,
+        action.to ? `to: ${quoteJsString(action.to)}` : null,
+        action.onClick ? `onClick: ${action.onClick}` : null,
+        typeof action.order === 'number' ? `order: ${action.order}` : null,
+        action.side ? `side: ${quoteJsString(action.side)}` : null,
+    ];
+    return jsObjectLiteral(entries);
+}
+export function buildExtensionPageShellSnippet(input) {
+    const title = input.titleExpression || quoteJsString(input.title || 'Untitled');
+    const headerEntries = [
+        `title: ${title}`,
+        input.description ? `description: ${quoteJsString(input.description)}` : null,
+        input.leadingIcon ? `leadingIcon: ${quoteJsString(input.leadingIcon)}` : null,
+        `gradient: ${quoteJsString(input.gradient || 'none')}`,
+        `variant: ${quoteJsString(input.variant || 'minimal')}`,
+    ];
+    const actions = Array.isArray(input.headerActions) ? input.headerActions : [];
+    const lines = [
+        'const { registerPageHeader } = usePageHeaderRegistry();',
+        `registerPageHeader(${jsObjectLiteral(headerEntries)});`,
+    ];
+    if (actions.length) {
+        lines.push('const { register: registerHeaderActions } = useHeaderActionRegistry();');
+        lines.push(`registerHeaderActions([\n${actions.map((action) => `  ${buildHeaderActionLiteral(action)}`).join(',\n')}\n]);`);
+    }
+    return {
+        action: 'extension_page_shell_built',
+        snippet: lines.join('\n'),
+        contract: [
+            'Use usePageHeaderRegistry so the app shell renders the page header.',
+            'Use useHeaderActionRegistry for toolbar actions instead of rendering duplicate page headers or local top bars.',
+            'Use primary solid only for the main scope action; secondary actions default to neutral outline.',
+        ],
+    };
+}
+export function buildExtensionPermissionGateSnippet(input) {
+    const normalized = normalizeVueBodySnippet(input.body || '<slot />');
+    let condition;
+    if (input.condition) {
+        condition = input.condition;
+    }
+    else if (input.route) {
+        const methods = Array.isArray(input.methods) && input.methods.length ? input.methods : ['GET'];
+        condition = `{ or: [{ route: ${quoteJsString(input.route)}, methods: [${methods.map(quoteJsString).join(', ')}] }] }`;
+    }
+    else {
+        condition = 'null';
+    }
+    const snippet = [
+        `<PermissionGate :condition="${condition}">`,
+        indentLines(normalized.code, 2),
+        '</PermissionGate>',
+    ].join('\n');
+    return {
+        action: 'extension_permission_gate_built',
+        component: 'PermissionGate',
+        snippet,
+        normalizedBodyChanges: normalized.changes,
+        warnings: condition === 'null' ? ['No condition/route was provided. PermissionGate with null condition permits the slot.'] : [],
+        contract: [
+            'PermissionGate is only operator UX; backend route permissions and owner checks remain authoritative.',
+            'PermissionGate renders its slot directly and should not be used as a layout wrapper.',
+        ],
+    };
+}
+export function buildExtensionEmptyStateSnippet(input) {
+    const action = input.action
+        ? `\n  :action="${buildFooterActionObject(input.action)}"`
+        : '';
+    return {
+        action: 'extension_empty_state_built',
+        component: 'CommonEmptyState',
+        snippet: `<CommonEmptyState\n  title="${String(input.title || 'No items found').replace(/"/g, '&quot;')}"\n  description="${String(input.description || '').replace(/"/g, '&quot;')}"\n  icon="${input.icon || 'lucide:inbox'}"\n  size="${input.size || 'sm'}"\n  variant="${input.variant || 'naked'}"${action}\n/>`,
+        contract: [
+            'Use CommonEmptyState for app-matched empty states.',
+            'Use variant="naked" inside framed panels/lists and outline/subtle for standalone framed empty surfaces.',
+        ],
+    };
+}
+export function buildExtensionResourceListSnippet(input) {
+    const itemsExpression = input.itemsExpression || 'items';
+    const itemName = input.itemName || 'item';
+    const keyExpression = input.keyExpression || `${itemName}.id`;
+    const titleExpression = input.titleExpression || `${itemName}.title || ${quoteJsString('Untitled')}`;
+    const descriptionExpression = input.descriptionExpression || `${itemName}.description`;
+    const iconExpression = input.iconExpression || quoteJsString(input.icon || 'lucide:file-text');
+    const onClick = input.onClick ? `\n      :on-click="() => ${input.onClick}"` : '';
+    const stats = input.statsExpression ? `\n      :stats="${input.statsExpression}"` : '';
+    const actions = input.actionsExpression ? `\n      :actions="${input.actionsExpression}"` : '';
+    const topBadge = input.topBadgeExpression ? `\n      :top-badge="${input.topBadgeExpression}"` : '';
+    const snippet = [
+        '<CommonResourceListFrame',
+        `  :loading="${input.loadingExpression || 'pending'}"`,
+        `  :has-items="${itemsExpression}.length > 0"`,
+        `  :total="${input.totalExpression || `${itemsExpression}.length`}"`,
+        `  :items-per-page="${input.itemsPerPageExpression || '0'}"`,
+        `  empty-title="${String(input.emptyTitle || 'No items found').replace(/"/g, '&quot;')}"`,
+        `  empty-description="${String(input.emptyDescription || '').replace(/"/g, '&quot;')}"`,
+        `  empty-icon="${input.emptyIcon || 'lucide:inbox'}"`,
+        '>',
+        `  <CommonResourceListItem`,
+        `    v-for="${itemName} in ${itemsExpression}"`,
+        `    :key="${keyExpression}"`,
+        `    :title="${titleExpression}"`,
+        `    :description="${descriptionExpression}"`,
+        `    :icon="${iconExpression}"`,
+        '    icon-color="primary"',
+        `${stats}${actions}${topBadge}${onClick}`,
+        '  />',
+        '</CommonResourceListFrame>',
+    ].join('\n');
+    return {
+        action: 'extension_resource_list_built',
+        components: ['CommonResourceListFrame', 'CommonResourceListItem'],
+        snippet,
+        contract: [
+            'Use CommonResourceListFrame and CommonResourceListItem for operational lists instead of ad hoc cards.',
+            'Keep first-load skeleton, empty state, and pagination owned by the frame.',
+            'Use explicit bounded list data and natural pagination/search outside this snippet when the domain list can grow.',
+        ],
+    };
+}
+export function buildExtensionFormEditorSnippet(input) {
+    const tag = input.lazy === false ? 'FormEditor' : 'FormEditorLazy';
+    const attrs = [
+        `v-model="${input.model || 'form'}"`,
+        `v-model:errors="${input.errors || 'errors'}"`,
+        attrStaticOrBound('table-name', input.tableName, input.tableNameExpression),
+        input.mode ? `mode="${input.mode}"` : null,
+        input.loadingExpression ? `:loading="${input.loadingExpression}"` : null,
+        input.layout ? `layout="${input.layout}"` : null,
+        input.includes?.length ? `:includes="${jsArrayLiteral(input.includes)}"` : null,
+        input.excluded?.length ? `:excluded="${jsArrayLiteral(input.excluded)}"` : null,
+        input.sectionsExpression ? `:sections="${input.sectionsExpression}"` : null,
+        input.fieldMapExpression ? `:field-map="${input.fieldMapExpression}"` : null,
+        input.virtualFieldsExpression ? `:virtual-fields="${input.virtualFieldsExpression}"` : null,
+        input.currentRecordIdExpression ? `:current-record-id="${input.currentRecordIdExpression}"` : null,
+        input.hasChangedHandler ? `@has-changed="${input.hasChangedHandler}"` : null,
+        input.virtualFieldEmitHandler ? `@virtual-field-emit="${input.virtualFieldEmitHandler}"` : null,
+    ].filter(Boolean);
+    const snippet = [
+        `<${tag}`,
+        ...attrs.map((attr) => `  ${attr}`),
+        '/>',
+    ].join('\n');
+    return {
+        action: 'extension_form_editor_built',
+        component: tag,
+        snippet,
+        contract: [
+            'Prefer FormEditor/FormEditorLazy for direct table-backed forms instead of hand-built UInput/UTextarea fields.',
+            'Use v-model for record state and v-model:errors for validation errors.',
+            'Use includes/sections to keep generated forms focused; do not expose compiledCode or unrelated system fields.',
+            'Use fieldMap only for behavior/renderer overrides such as code fields or custom labels.',
+        ],
+    };
+}
+export function buildExtensionWidgetSnippet(input) {
+    const attrs = [`:id="${typeof input.id === 'number' ? input.id : quoteJsString(input.id)}"`];
+    for (const [key, value] of Object.entries(input.props || {})) {
+        attrs.push(`:${key}="${value}"`);
+    }
+    for (const [event, handler] of Object.entries(input.events || {})) {
+        attrs.push(`@${event}="${handler}"`);
+    }
+    return {
+        action: 'extension_widget_built',
+        component: 'Widget',
+        snippet: `<Widget ${attrs.join(' ')} />`,
+        warnings: typeof input.id === 'number' ? [] : ['Widget ids should be numeric enfyra_extension ids; do not pass extension name or extensionId string.'],
+        contract: [
+            'Widget :id is the numeric enfyra_extension id, not name or extensionId.',
+            'Pass safe props/events; keep page-level mutation and modal ownership in the page unless the widget intentionally owns the full workflow.',
+        ],
+    };
+}
+export function buildExtensionMenuNotificationSnippet(input) {
+    const targetEntries = [
+        input.targetId !== undefined ? `id: ${quoteJsString(input.targetId)}` : null,
+        input.path ? `path: ${quoteJsString(input.path)}` : null,
+        input.route ? `route: ${quoteJsString(input.route)}` : null,
+    ];
+    const entries = [
+        `id: ${quoteJsString(input.id || 'extension-menu-notification')}`,
+        `target: ${jsObjectLiteral(targetEntries)}`,
+        input.valueExpression ? `value: ${input.valueExpression}` : input.value !== undefined ? `value: ${quoteJsString(input.value)}` : null,
+        `color: ${quoteJsString(input.color || 'primary')}`,
+        input.title ? `title: ${quoteJsString(input.title)}` : null,
+        typeof input.order === 'number' ? `order: ${input.order}` : null,
+    ];
+    return {
+        action: 'extension_menu_notification_built',
+        snippet: [
+            'const { register: registerMenuNotification } = useMenuNotificationRegistry();',
+            `registerMenuNotification(${jsObjectLiteral(entries)});`,
+        ].join('\n'),
+        contract: [
+            'Use count/value only when the signal source already owns an exact or bounded count.',
+            'Omit value for a dot-only notification when realtime only proves new attention exists.',
+            'Do not fetch destination domain lists solely to decorate the menu.',
+        ],
+    };
+}
+export function buildExtensionAccountPanelSnippet(input) {
+    const entries = [
+        `id: ${quoteJsString(input.id || 'extension-account-panel-item')}`,
+        typeof input.order === 'number' ? `order: ${input.order}` : null,
+        input.label ? `label: ${quoteJsString(input.label)}` : null,
+        input.description ? `description: ${quoteJsString(input.description)}` : null,
+        input.icon ? `icon: ${quoteJsString(input.icon)}` : null,
+        input.countExpression ? `count: ${input.countExpression}` : input.count !== undefined ? `count: ${quoteJsString(input.count)}` : null,
+        input.badgeExpression ? `badge: ${input.badgeExpression}` : input.badge !== undefined ? `badge: ${quoteJsString(input.badge)}` : null,
+        input.badgeColor ? `badgeColor: ${quoteJsString(input.badgeColor)}` : null,
+        input.trailingIcon ? `trailingIcon: ${quoteJsString(input.trailingIcon)}` : null,
+        input.expandedExpression ? `expanded: ${input.expandedExpression}` : null,
+        input.contentComponent ? `contentComponent: ${input.contentComponent}` : null,
+        input.contentPropsExpression ? `contentProps: ${input.contentPropsExpression}` : null,
+        input.onClick ? `onClick: ${input.onClick}` : null,
+        input.onToggle ? `onToggle: ${input.onToggle}` : null,
+    ];
+    return {
+        action: 'extension_account_panel_item_built',
+        snippet: [
+            'const { register: registerAccountPanelItem } = useAccountPanelRegistry();',
+            `registerAccountPanelItem(${jsObjectLiteral(entries)});`,
+        ].join('\n'),
+        contract: [
+            'Prefer data-driven account panel rows over fully custom row components.',
+            'Use count for notification-style chips; count takes precedence over badge.',
+            'Use onClick for direct actions and onToggle/contentComponent for expandable inline UI.',
+        ],
+    };
+}
+export function buildExtensionTabsSnippet(input) {
+    const model = input.model || 'activeTab';
+    const items = input.itemsExpression || 'tabs';
+    const body = input.body || '<div>{{ item.label }}</div>';
+    const snippet = [
+        `<UTabs v-model="${model}" :items="${items}" class="w-full">`,
+        '  <template #content="{ item }">',
+        indentLines(normalizeVueBodySnippet(body).code, 4),
+        '  </template>',
+        '</UTabs>',
+    ].join('\n');
+    return {
+        action: 'extension_tabs_built',
+        component: 'UTabs',
+        snippet,
+        contract: [
+            'Use app-level UTabs chrome instead of custom tab bars.',
+            'Do not add local full-width bottom borders/dividers to tab lists.',
+            'Keep tab items data-driven and render panel content through #content.',
+        ],
+    };
+}
+export function buildExtensionUploadModalSnippet(input) {
+    const model = input.model || 'showUploadModal';
+    const attrs = [
+        `v-model="${model}"`,
+        `title="${String(input.title || 'Upload Files').replace(/"/g, '&quot;')}"`,
+        `accept="${input.accept || '*/*'}"`,
+        input.multiple !== false ? ':multiple="true"' : ':multiple="false"',
+        input.maxSizeExpression ? `:max-size="${input.maxSizeExpression}"` : ':max-size="10 * 1024 * 1024"',
+        input.loadingExpression ? `:loading="${input.loadingExpression}"` : null,
+        input.uploadProgressExpression ? `:upload-progress="${input.uploadProgressExpression}"` : null,
+        input.fileProgressExpression ? `:file-progress="${input.fileProgressExpression}"` : null,
+        input.dragText ? `drag-text="${String(input.dragText).replace(/"/g, '&quot;')}"` : null,
+        input.acceptText ? `accept-text="${String(input.acceptText).replace(/"/g, '&quot;')}"` : null,
+        input.uploadText ? `upload-text="${String(input.uploadText).replace(/"/g, '&quot;')}"` : null,
+        input.uploadingText ? `uploading-text="${String(input.uploadingText).replace(/"/g, '&quot;')}"` : null,
+        `@upload="${input.uploadHandler || 'handleUpload'}"`,
+        input.errorHandler ? `@error="${input.errorHandler}"` : null,
+    ].filter(Boolean);
+    const headerContent = input.headerContent ? [
+        '>',
+        '  <template #header-content>',
+        indentLines(normalizeVueBodySnippet(input.headerContent).code, 4),
+        '  </template>',
+        '</CommonUploadModal>',
+    ] : ['/>'];
+    return {
+        action: 'extension_upload_modal_built',
+        component: 'CommonUploadModal',
+        snippet: [
+            '<CommonUploadModal',
+            ...attrs.map((attr) => `  ${attr}`),
+            ...headerContent,
+        ].join('\n'),
+        companionSnippet: [
+            'const {',
+            '  uploadProgress,',
+            '  trackedUploadProgressById,',
+            '  beginTrackedUploadProgress,',
+            '  getUploadProgressHeaders,',
+            '  resetUploadProgress,',
+            '} = useFileUploadProgress();',
+        ].join('\n'),
+        contract: [
+            'Use useFileUploadProgress for admin-socket upload progress.',
+            'Send x-enfyra-upload-id via getUploadProgressHeaders(id) for each uploaded file.',
+            'For multi-file uploads, call the useApi batch files path once, pass per-file headers through headersByIndex, and map each upload id to fileProgress[index].',
+            'CommonUploadModal owns selected-file rows and per-row progress chrome.',
+        ],
+    };
+}
 export function reviewExtensionUiContract(code) {
     const source = String(code || '');
     const issues = [];
@@ -583,6 +946,7 @@ function getExtensionThemeContract() {
             'Buttons should have stable geometry: hover may change color, border, or shadow but must not move the button or resize its content. Disabled buttons keep disabled cursor/visual state.',
             'Inputs and textareas should not add hover movement or decorative hover states; focus, invalid, disabled, and loading states must be explicit.',
             'Inside CommonDrawer/CommonModal body forms, UInput, UTextarea, USelect, USelectMenu, and similar field controls must use class="w-full" unless the control is intentionally inline or compact.',
+            'Extension validation rejects UInput, UTextarea, USelect, USelectMenu, UInputMenu, UInputNumber, UInputTags, UInputTime, and UInputDate without class="w-full" unless marked data-compact or data-inline.',
             'Dynamic extensions resolve UModal to the app CommonModal. Do not pass ui.content: "eapp-surface-card" or "surface-card" to UModal/CommonModal; modal content uses the app modal surface and caller ui.content should only append z-index, width, or max-width classes.',
             'CommonModal and CommonDrawer own action-only footers through cancelAction, primaryAction, dangerAction, leadingActions, and footerHint. Pass footer button intent through those props instead of custom footer slots. cancelAction defaults to neutral outline; use dangerAction for irreversible destructive work and tone: "primary" for Keep editing in discard dialogs.',
             'Use custom #footer content only when the footer contains real custom layout or non-button content. Every modal/drawer button should use type="button" unless it intentionally submits a form.',
@@ -863,7 +1227,12 @@ export function validateExtensionCodeLocally(code) {
         const first = violations[0];
         throw new Error(`Invalid extension component casing: use <${first.expected}> instead of <${first.tag}>. Enfyra/Nuxt UI auto-injected components must keep PascalCase in extension templates; lowercase tags render as unresolved DOM elements.`);
     }
-    return { componentCasing: 'passed' };
+    const missingFullWidthFields = findMissingFullWidthFieldControls(code);
+    if (missingFullWidthFields.length) {
+        const first = missingFullWidthFields[0];
+        throw new Error(`Invalid extension field width: <${first.tag}> must include class="w-full" in Enfyra extensions unless it is intentionally compact with data-compact or data-inline. First offending snippet: ${first.snippet}`);
+    }
+    return { componentCasing: 'passed', fieldWidth: 'passed' };
 }
 export async function validateExtensionCode(apiUrl, code, name) {
     const localChecks = validateExtensionCodeLocally(code);
@@ -2075,6 +2444,19 @@ export function registerPlatformOperationTools(server, ENFYRA_API_URL) {
         tone: z.string().optional().describe('Optional action tone when supported by the shell component.'),
         onClick: z.string().describe('Raw Vue expression or function reference for the click handler, e.g. saveNote or () => (open = false).'),
     });
+    const extensionHeaderActionSchema = z.object({
+        id: z.string().describe('Stable action id.'),
+        label: z.string().optional().describe('Action label.'),
+        icon: z.string().optional().describe('Icon name such as lucide:plus or lucide:refresh-cw.'),
+        color: z.string().optional().default('neutral').describe('Nuxt UI color. Use primary only for the single main scope action; otherwise neutral.'),
+        variant: z.string().optional().default('outline').describe('Nuxt UI variant. Use solid for the main scope action; otherwise outline/ghost.'),
+        loading: z.string().optional().describe('Raw Vue expression/ref name for loading state.'),
+        disabled: z.string().optional().describe('Raw Vue expression/ref name for disabled state.'),
+        to: z.string().optional().describe('Route path for visible navigation actions.'),
+        onClick: z.string().optional().describe('Raw Vue expression or function reference for click behavior.'),
+        order: z.number().optional().describe('Sort order in the shell header action area.'),
+        side: z.enum(['left', 'right']).optional().describe('Optional shell side.'),
+    });
     server.tool('validate_dynamic_script', [
         'Validate Enfyra dynamic script code before saving it to any script-backed metadata record.',
         'Use this before create/update of handlers, hooks, flow steps, websocket scripts, GraphQL scripts, or bootstrap scripts when the user is iterating on code.',
@@ -2187,6 +2569,152 @@ export function registerPlatformOperationTools(server, ENFYRA_API_URL) {
     ].join(' '), {
         code: z.string().describe('Vue SFC or template snippet to review.'),
     }, async ({ code }) => jsonText(reviewExtensionUiContract(code)));
+    server.tool('build_extension_page_shell', [
+        'Generate page-header and shell-header-action script setup code for Enfyra page extensions.',
+        'Use this so generated page extensions register shell chrome through usePageHeaderRegistry/useHeaderActionRegistry instead of rendering duplicate local headers.',
+    ].join(' '), {
+        title: z.string().optional().describe('Static page title.'),
+        titleExpression: z.string().optional().describe('Raw Vue expression for a dynamic title.'),
+        description: z.string().optional().describe('Optional page description.'),
+        leadingIcon: z.string().optional().describe('Optional page header icon.'),
+        gradient: z.enum(['none', 'purple', 'blue', 'cyan']).optional().default('none').describe('Generated operational extensions should usually use none.'),
+        variant: z.enum(['default', 'minimal', 'stats-focus']).optional().default('minimal').describe('Page header variant.'),
+        headerActions: z.array(extensionHeaderActionSchema).optional().describe('Optional shell header actions registered through useHeaderActionRegistry.'),
+    }, async (input) => jsonText(buildExtensionPageShellSnippet(input)));
+    server.tool('build_extension_permission_gate', [
+        'Generate a PermissionGate wrapper snippet for Enfyra admin extension UI.',
+        'Use this when a visible button/block/list needs operator UX gating; backend route permissions and owner checks still remain authoritative.',
+    ].join(' '), {
+        route: z.string().optional().describe('API route path to gate against, e.g. /notes.'),
+        methods: z.array(z.string()).optional().describe('HTTP methods for the route condition. Defaults to GET when route is provided.'),
+        condition: z.string().optional().describe('Raw Vue permission condition expression. Overrides route/methods when provided.'),
+        body: z.string().describe('Vue template content to render inside PermissionGate. Field controls are normalized to w-full.'),
+    }, async (input) => jsonText(buildExtensionPermissionGateSnippet(input)));
+    server.tool('build_extension_empty_state', [
+        'Generate a CommonEmptyState snippet for Enfyra admin extensions.',
+        'Use this for app-matched empty/error/no-results states instead of hand-rolled blank panels.',
+    ].join(' '), {
+        title: z.string().optional().describe('Empty state title.'),
+        description: z.string().optional().describe('Empty state description.'),
+        icon: z.string().optional().describe('Icon name. Defaults to lucide:inbox.'),
+        size: z.enum(['sm', 'md', 'lg']).optional().default('sm').describe('Empty state size.'),
+        variant: z.enum(['outline', 'naked', 'soft', 'subtle', 'solid']).optional().default('naked').describe('Use naked inside existing panels/lists.'),
+        action: extensionFooterActionSchema.optional().describe('Optional primary empty-state action.'),
+    }, async (input) => jsonText(buildExtensionEmptyStateSnippet(input)));
+    server.tool('build_extension_resource_list', [
+        'Generate a CommonResourceListFrame/CommonResourceListItem snippet for Enfyra admin extensions.',
+        'Use this for operational list pages so loading, empty state, pagination placement, row chrome, icons, stats, and row actions follow the app contract.',
+    ].join(' '), {
+        itemsExpression: z.string().optional().default('items').describe('Vue expression for the row array, e.g. notes.'),
+        itemName: z.string().optional().default('item').describe('Loop variable name.'),
+        keyExpression: z.string().optional().describe('Vue expression for :key. Defaults to item.id.'),
+        titleExpression: z.string().optional().describe('Vue expression for item title. Defaults to item.title || "Untitled".'),
+        descriptionExpression: z.string().optional().describe('Vue expression for item description. Defaults to item.description.'),
+        icon: z.string().optional().describe('Static row icon when iconExpression is omitted.'),
+        iconExpression: z.string().optional().describe('Vue expression for row icon.'),
+        loadingExpression: z.string().optional().default('pending').describe('Vue expression for frame loading.'),
+        totalExpression: z.string().optional().describe('Vue expression for total rows.'),
+        itemsPerPageExpression: z.string().optional().describe('Vue expression for items per page; use 0 to hide pagination.'),
+        statsExpression: z.string().optional().describe('Vue expression returning ResourceListStat[] for each row.'),
+        actionsExpression: z.string().optional().describe('Vue expression returning ResourceListAction[] for each row.'),
+        topBadgeExpression: z.string().optional().describe('Vue expression returning a ResourceListTopBadge for each row.'),
+        onClick: z.string().optional().describe('Raw Vue expression called for row click, e.g. openEdit(item).'),
+        emptyTitle: z.string().optional().describe('Empty title.'),
+        emptyDescription: z.string().optional().describe('Empty description.'),
+        emptyIcon: z.string().optional().describe('Empty icon.'),
+    }, async (input) => jsonText(buildExtensionResourceListSnippet(input)));
+    server.tool('build_extension_form_editor', [
+        'Generate a FormEditor/FormEditorLazy snippet for Enfyra table-backed extension forms.',
+        'Use this instead of hand-writing UInput/UTextarea fields when the form maps directly to a table record.',
+    ].join(' '), {
+        tableName: z.string().optional().describe('Static table name.'),
+        tableNameExpression: z.string().optional().describe('Raw Vue expression for dynamic table name.'),
+        model: z.string().optional().default('form').describe('Record state variable for v-model.'),
+        errors: z.string().optional().default('errors').describe('Errors state variable for v-model:errors.'),
+        mode: z.enum(['create', 'update']).optional().describe('Optional fixed form mode.'),
+        loadingExpression: z.string().optional().describe('Raw Vue expression/ref for loading.'),
+        layout: z.enum(['stack', 'grid']).optional().describe('Form layout.'),
+        includes: z.array(z.string()).optional().describe('Fields to include. Prefer explicit includes for focused generated forms.'),
+        excluded: z.array(z.string()).optional().describe('Fields to exclude. compiledCode is always excluded by FormEditor.'),
+        sectionsExpression: z.string().optional().describe('Raw Vue expression for FormEditorSection[].'),
+        fieldMapExpression: z.string().optional().describe('Raw Vue expression for fieldMap overrides.'),
+        virtualFieldsExpression: z.string().optional().describe('Raw Vue expression for virtual fields.'),
+        currentRecordIdExpression: z.string().optional().describe('Raw Vue expression for current record id.'),
+        hasChangedHandler: z.string().optional().describe('Handler expression for @has-changed.'),
+        virtualFieldEmitHandler: z.string().optional().describe('Handler expression for @virtual-field-emit.'),
+        lazy: z.boolean().optional().default(true).describe('Use FormEditorLazy by default.'),
+    }, async (input) => jsonText(buildExtensionFormEditorSnippet(input)));
+    server.tool('build_extension_widget', [
+        'Generate a Widget snippet for reusing a widget extension inside an Enfyra page extension.',
+        'Use this so agents pass numeric widget ids and keep prop/event ownership explicit.',
+    ].join(' '), {
+        id: z.union([z.number(), z.string()]).describe('Numeric enfyra_extension widget id. Strings are allowed but return a warning because names/extensionId are wrong for Widget.'),
+        props: z.record(z.string()).optional().describe('Map of prop name to raw Vue expression.'),
+        events: z.record(z.string()).optional().describe('Map of event name to handler expression.'),
+    }, async (input) => jsonText(buildExtensionWidgetSnippet(input)));
+    server.tool('build_extension_menu_notification', [
+        'Generate useMenuNotificationRegistry registration code for a global extension.',
+        'Use this for sidebar menu count chips or dot notifications without mutating enfyra_menu records.',
+    ].join(' '), {
+        id: z.string().optional().describe('Stable notification id.'),
+        targetId: z.union([z.string(), z.number()]).optional().describe('Target menu id.'),
+        path: z.string().optional().describe('Target menu path.'),
+        route: z.string().optional().describe('Target route path.'),
+        value: z.union([z.string(), z.number()]).optional().describe('Static count/chip value. Omit with valueExpression for a dot.'),
+        valueExpression: z.string().optional().describe('Raw Vue expression for count/chip value. Omit value for a dot-only notification.'),
+        color: z.enum(['primary', 'success', 'warning', 'error', 'info', 'neutral']).optional().default('primary').describe('Chip/dot color intent.'),
+        title: z.string().optional().describe('Optional tooltip/title.'),
+        order: z.number().optional().describe('Sort order when multiple notifications target the same menu.'),
+    }, async (input) => jsonText(buildExtensionMenuNotificationSnippet(input)));
+    server.tool('build_extension_account_panel_item', [
+        'Generate useAccountPanelRegistry registration code for a global extension.',
+        'Use this for data-driven account panel rows instead of drawing full custom sidebar/account UI.',
+    ].join(' '), {
+        id: z.string().optional().describe('Stable account panel item id.'),
+        order: z.number().optional().describe('Display order.'),
+        label: z.string().optional().describe('Row label.'),
+        description: z.string().optional().describe('Row description.'),
+        icon: z.string().optional().describe('Leading icon.'),
+        count: z.union([z.string(), z.number()]).optional().describe('Static notification chip value.'),
+        countExpression: z.string().optional().describe('Raw Vue expression for notification chip value.'),
+        badge: z.union([z.string(), z.number()]).optional().describe('Legacy static badge value. Prefer count.'),
+        badgeExpression: z.string().optional().describe('Raw Vue expression for badge. Prefer countExpression.'),
+        badgeColor: z.enum(['primary', 'neutral', 'info', 'error', 'warning', 'success']).optional().describe('Chip color.'),
+        trailingIcon: z.string().optional().describe('Trailing icon.'),
+        expandedExpression: z.string().optional().describe('Raw Vue expression controlling expanded state.'),
+        contentComponent: z.string().optional().describe('Raw component reference for inline expanded content.'),
+        contentPropsExpression: z.string().optional().describe('Raw Vue expression for content props.'),
+        onClick: z.string().optional().describe('Direct action handler expression.'),
+        onToggle: z.string().optional().describe('Expandable row toggle handler expression.'),
+    }, async (input) => jsonText(buildExtensionAccountPanelSnippet(input)));
+    server.tool('build_extension_tabs', [
+        'Generate a UTabs snippet for Enfyra extension page sections.',
+        'Use this instead of custom tab bars so app-wide tab chrome owns active indicators, focus rings, spacing, and theme contrast.',
+    ].join(' '), {
+        model: z.string().optional().default('activeTab').describe('Active tab model variable.'),
+        itemsExpression: z.string().optional().default('tabs').describe('Raw Vue expression for tab items.'),
+        body: z.string().optional().describe('Vue template body for #content="{ item }".'),
+    }, async (input) => jsonText(buildExtensionTabsSnippet(input)));
+    server.tool('build_extension_upload_modal', [
+        'Generate a CommonUploadModal snippet and upload-progress companion snippet for Enfyra extensions.',
+        'Use this for file upload UI so progress, selected-file rows, and x-enfyra-upload-id wiring follow the app contract.',
+    ].join(' '), {
+        model: z.string().optional().default('showUploadModal').describe('Modal open state variable.'),
+        title: z.string().optional().describe('Upload modal title.'),
+        accept: z.string().optional().default('*/*').describe('Accepted mime/extensions.'),
+        multiple: z.boolean().optional().default(true).describe('Allow multiple files.'),
+        maxSizeExpression: z.string().optional().describe('Raw Vue expression for max file size.'),
+        loadingExpression: z.string().optional().describe('Raw Vue expression/ref for upload pending state.'),
+        uploadProgressExpression: z.string().optional().describe('Raw Vue expression/ref for aggregate upload progress.'),
+        fileProgressExpression: z.string().optional().describe('Raw Vue expression for per-row progress map.'),
+        dragText: z.string().optional().describe('Drag/drop text.'),
+        acceptText: z.string().optional().describe('Accept/help text.'),
+        uploadText: z.string().optional().describe('Upload action text.'),
+        uploadingText: z.string().optional().describe('Uploading action text.'),
+        uploadHandler: z.string().optional().default('handleUpload').describe('@upload handler expression.'),
+        errorHandler: z.string().optional().describe('@error handler expression.'),
+        headerContent: z.string().optional().describe('Optional #header-content template, e.g. storage selector. Fields are normalized to w-full.'),
+    }, async (input) => jsonText(buildExtensionUploadModalSnippet(input)));
     server.tool('extension_workflow', [
         'Step-by-step workflow for creating or updating Enfyra admin page, global, or widget extensions.',
         'Use this when an LLM is building extension UI, menu shell notifications, account panel entries, or page/menu wiring and should follow live nextSteps instead of guessing raw enfyra_extension mutations.',