foundrycms 0.1.0

package/dist/plugins/communication.js

@@ -0,0 +1,922 @@
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Relay — Messaging Hub
+// ---------------------------------------------------------------------------
+export const relayPlugin = {
+    id: '@foundry/relay',
+    name: 'Relay',
+    version: '1.0.0',
+    description: 'Messaging hub with email, SMS, in-app notifications, and templated communication',
+    adminPages: [
+        {
+            path: 'relay',
+            label: 'Messaging',
+            icon: 'send',
+            component: 'RelayDashboardPage',
+            order: 45,
+            permission: 'relay:view',
+            children: [
+                {
+                    path: 'inbox',
+                    label: 'Inbox',
+                    component: 'RelayInboxPage',
+                    permission: 'relay:view',
+                },
+                {
+                    path: 'templates',
+                    label: 'Templates',
+                    component: 'RelayTemplatesPage',
+                    permission: 'relay:manage',
+                },
+                {
+                    path: 'campaigns',
+                    label: 'Campaigns',
+                    component: 'RelayCampaignsPage',
+                    permission: 'relay:campaigns',
+                },
+                {
+                    path: 'logs',
+                    label: 'Send Log',
+                    component: 'RelayLogsPage',
+                    permission: 'relay:view',
+                },
+                {
+                    path: 'settings',
+                    label: 'Settings',
+                    component: 'RelaySettingsPage',
+                    permission: 'relay:settings',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'POST',
+            path: '/api/relay/send',
+            handler: 'relay.sendMessage',
+            middleware: ['auth', 'permission:relay:send'],
+            description: 'Send a message via email, SMS, or in-app',
+        },
+        {
+            method: 'POST',
+            path: '/api/relay/send-template',
+            handler: 'relay.sendTemplate',
+            middleware: ['auth', 'permission:relay:send'],
+            description: 'Send a templated message',
+        },
+        {
+            method: 'GET',
+            path: '/api/relay/templates',
+            handler: 'relay.listTemplates',
+            middleware: ['auth'],
+            description: 'List message templates',
+        },
+        {
+            method: 'POST',
+            path: '/api/relay/templates',
+            handler: 'relay.createTemplate',
+            middleware: ['auth', 'permission:relay:manage'],
+            description: 'Create a message template',
+        },
+        {
+            method: 'GET',
+            path: '/api/relay/notifications',
+            handler: 'relay.getNotifications',
+            middleware: ['auth'],
+            description: 'Get in-app notifications for current user',
+        },
+        {
+            method: 'PATCH',
+            path: '/api/relay/notifications/:id/read',
+            handler: 'relay.markRead',
+            middleware: ['auth'],
+            description: 'Mark a notification as read',
+        },
+        {
+            method: 'POST',
+            path: '/api/relay/webhooks/email',
+            handler: 'relay.emailWebhook',
+            description: 'Incoming email webhook (SendGrid/Postmark)',
+        },
+    ],
+    widgets: [
+        {
+            id: 'relay-notifications',
+            name: 'Notifications',
+            component: 'RelayNotificationsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+        {
+            id: 'relay-send-stats',
+            name: 'Message Stats',
+            component: 'RelaySendStatsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                // Auto-send notifications for important content events
+                if (payload.content?.type === 'notification') {
+                    const notification = payload.content;
+                    // Queue the notification for delivery
+                    _notificationQueue.push({
+                        id: notification.id ?? `notif-${Date.now()}`,
+                        channel: notification.channel ?? 'in-app',
+                        recipient: notification.recipient,
+                        subject: notification.subject,
+                        body: notification.body,
+                        templateId: notification.templateId,
+                        templateData: notification.templateData,
+                        status: 'queued',
+                        createdAt: new Date().toISOString(),
+                    });
+                }
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        emailProvider: z.enum(['sendgrid', 'postmark', 'ses', 'smtp']).default('smtp'),
+        emailApiKey: z.string().optional(),
+        smtpHost: z.string().optional(),
+        smtpPort: z.number().optional(),
+        smtpUser: z.string().optional(),
+        smtpPass: z.string().optional(),
+        fromEmail: z.string().email().optional(),
+        fromName: z.string().default(''),
+        smsProvider: z.enum(['twilio', 'vonage', 'none']).default('none'),
+        smsApiKey: z.string().optional(),
+        smsFromNumber: z.string().optional(),
+        enableInAppNotifications: z.boolean().default(true),
+        notificationRetentionDays: z.number().min(7).max(365).default(90),
+    }),
+    async onActivate(_core) {
+        _notificationQueue.length = 0;
+    },
+    async onDeactivate(_core) {
+        _notificationQueue.length = 0;
+    },
+};
+const _notificationQueue = [];
+// ---------------------------------------------------------------------------
+// Canvas — Form Builder
+// ---------------------------------------------------------------------------
+export const canvasPlugin = {
+    id: '@foundry/canvas',
+    name: 'Canvas',
+    version: '1.0.0',
+    description: 'Drag-and-drop form builder with conditional logic, file uploads, and submission management',
+    adminPages: [
+        {
+            path: 'canvas',
+            label: 'Forms',
+            icon: 'clipboard',
+            component: 'CanvasDashboardPage',
+            order: 18,
+            permission: 'canvas:view',
+            children: [
+                {
+                    path: 'forms',
+                    label: 'All Forms',
+                    component: 'CanvasFormsPage',
+                    permission: 'canvas:view',
+                },
+                {
+                    path: 'forms/new',
+                    label: 'New Form',
+                    component: 'CanvasFormEditorPage',
+                    permission: 'canvas:create',
+                },
+                {
+                    path: 'forms/:id/edit',
+                    label: 'Edit Form',
+                    component: 'CanvasFormEditorPage',
+                    permission: 'canvas:edit',
+                },
+                {
+                    path: 'submissions',
+                    label: 'Submissions',
+                    component: 'CanvasSubmissionsPage',
+                    permission: 'canvas:view',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/canvas/forms',
+            handler: 'canvas.listForms',
+            middleware: ['auth'],
+            description: 'List all forms',
+        },
+        {
+            method: 'POST',
+            path: '/api/canvas/forms',
+            handler: 'canvas.createForm',
+            middleware: ['auth', 'permission:canvas:create'],
+            description: 'Create a new form',
+        },
+        {
+            method: 'GET',
+            path: '/api/canvas/forms/:id',
+            handler: 'canvas.getForm',
+            description: 'Get form definition (public for rendering)',
+        },
+        {
+            method: 'POST',
+            path: '/api/canvas/forms/:id/submit',
+            handler: 'canvas.submitForm',
+            middleware: ['rateLimit:forms'],
+            description: 'Submit a form response (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/canvas/forms/:id/submissions',
+            handler: 'canvas.listSubmissions',
+            middleware: ['auth', 'permission:canvas:view'],
+            description: 'List submissions for a form',
+        },
+        {
+            method: 'POST',
+            path: '/api/canvas/forms/:id/submissions/export',
+            handler: 'canvas.exportSubmissions',
+            middleware: ['auth', 'permission:canvas:export'],
+            description: 'Export submissions as CSV',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'form-embed',
+            name: 'Form',
+            category: 'interactive',
+            component: 'CanvasFormEmbed',
+            settingsSchema: z.object({
+                formId: z.string(),
+                theme: z.enum(['default', 'minimal', 'bordered']).default('default'),
+                submitButtonText: z.string().default('Submit'),
+                successMessage: z.string().default('Thank you for your submission!'),
+                redirectUrl: z.string().optional(),
+                showLabels: z.boolean().default(true),
+                layout: z.enum(['vertical', 'horizontal', 'inline']).default('vertical'),
+            }),
+        },
+        {
+            type: 'contact-form',
+            name: 'Contact Form',
+            category: 'interactive',
+            component: 'CanvasContactForm',
+            settingsSchema: z.object({
+                recipientEmail: z.string().email().optional(),
+                fields: z.array(z.enum(['name', 'email', 'phone', 'company', 'message', 'subject'])).default(['name', 'email', 'message']),
+                requireAll: z.boolean().default(false),
+                honeypot: z.boolean().default(true),
+                submitText: z.string().default('Send Message'),
+                successMessage: z.string().default('Thank you! We will get back to you soon.'),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'canvas-recent-submissions',
+            name: 'Recent Submissions',
+            component: 'CanvasRecentSubmissionsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+        {
+            id: 'canvas-form-stats',
+            name: 'Form Stats',
+            component: 'CanvasFormStatsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 2, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'form_submission') {
+                    const submission = payload.content;
+                    // Sanitize all text fields
+                    if (submission.data) {
+                        for (const [key, value] of Object.entries(submission.data)) {
+                            if (typeof value === 'string') {
+                                submission.data[key] = sanitizeFormInput(value);
+                            }
+                        }
+                    }
+                    // Check honeypot
+                    if (submission.data?._hp && submission.data._hp.length > 0) {
+                        throw new Error('Canvas: Spam detected');
+                    }
+                    // Add metadata
+                    submission.submittedAt = new Date().toISOString();
+                    submission.ipHash = submission._ip
+                        ? simpleHash(submission._ip)
+                        : undefined;
+                    delete submission._ip;
+                    delete submission.data?._hp;
+                }
+                return payload;
+            },
+            priority: 3,
+        },
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'form_submission') {
+                    // Notify via relay if configured
+                    if (payload.content.notifyEmail) {
+                        // Would trigger relay notification
+                    }
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        maxFileUploadMb: z.number().min(1).max(100).default(10),
+        allowedFileTypes: z.array(z.string()).default(['.pdf', '.jpg', '.png', '.doc', '.docx']),
+        spamProtection: z.enum(['honeypot', 'recaptcha', 'turnstile', 'none']).default('honeypot'),
+        recaptchaSiteKey: z.string().optional(),
+        recaptchaSecretKey: z.string().optional(),
+        storeSubmissions: z.boolean().default(true),
+        submissionRetentionDays: z.number().min(30).max(730).default(365),
+        notifyOnSubmission: z.boolean().default(true),
+        defaultNotifyEmail: z.string().email().optional(),
+    }),
+    async onActivate(core) {
+        // Wire form submissions to CRM contacts if compass is active
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'form_submission' && core.plugins.isActive('@foundry/compass')) {
+                const data = payload.content.data ?? {};
+                if (data.email) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'contact',
+                            email: data.email,
+                            name: data.name ?? data.fullName ?? '',
+                            phone: data.phone,
+                            company: data.company,
+                            source: 'form',
+                            sourceFormId: payload.content.formId,
+                            lifecycleStage: 'subscriber',
+                        },
+                    });
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+function sanitizeFormInput(str) {
+    return str
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;')
+        .trim()
+        .substring(0, 10000); // limit field length
+}
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+// ---------------------------------------------------------------------------
+// Market — E-commerce
+// ---------------------------------------------------------------------------
+export const marketPlugin = {
+    id: '@foundry/market',
+    name: 'Market',
+    version: '1.0.0',
+    description: 'E-commerce with product catalog, shopping cart, Stripe checkout, and order management',
+    requires: ['@foundry/ledger'],
+    adminPages: [
+        {
+            path: 'market',
+            label: 'Store',
+            icon: 'shopping-bag',
+            component: 'MarketDashboardPage',
+            order: 22,
+            permission: 'market:view',
+            children: [
+                {
+                    path: 'products',
+                    label: 'Products',
+                    component: 'MarketProductsPage',
+                    permission: 'market:view',
+                },
+                {
+                    path: 'products/new',
+                    label: 'New Product',
+                    component: 'MarketProductEditorPage',
+                    permission: 'market:create',
+                },
+                {
+                    path: 'orders',
+                    label: 'Orders',
+                    component: 'MarketOrdersPage',
+                    permission: 'market:orders',
+                },
+                {
+                    path: 'orders/:id',
+                    label: 'Order Detail',
+                    component: 'MarketOrderDetailPage',
+                    permission: 'market:orders',
+                },
+                {
+                    path: 'coupons',
+                    label: 'Coupons',
+                    component: 'MarketCouponsPage',
+                    permission: 'market:manage',
+                },
+                {
+                    path: 'categories',
+                    label: 'Categories',
+                    component: 'MarketCategoriesPage',
+                    permission: 'market:manage',
+                },
+                {
+                    path: 'shipping',
+                    label: 'Shipping',
+                    component: 'MarketShippingPage',
+                    permission: 'market:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/market/products',
+            handler: 'market.listProducts',
+            description: 'List products with filters (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/market/products/:slug',
+            handler: 'market.getProduct',
+            description: 'Get product by slug (public)',
+        },
+        {
+            method: 'POST',
+            path: '/api/market/products',
+            handler: 'market.createProduct',
+            middleware: ['auth', 'permission:market:create'],
+            description: 'Create a product',
+        },
+        {
+            method: 'POST',
+            path: '/api/market/cart',
+            handler: 'market.addToCart',
+            description: 'Add item to cart (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/market/cart',
+            handler: 'market.getCart',
+            description: 'Get current cart (public)',
+        },
+        {
+            method: 'DELETE',
+            path: '/api/market/cart/:itemId',
+            handler: 'market.removeFromCart',
+            description: 'Remove item from cart',
+        },
+        {
+            method: 'POST',
+            path: '/api/market/checkout',
+            handler: 'market.createCheckout',
+            description: 'Create Stripe checkout session',
+        },
+        {
+            method: 'POST',
+            path: '/api/market/webhooks/stripe',
+            handler: 'market.stripeWebhook',
+            description: 'Stripe webhook for order fulfillment',
+        },
+        {
+            method: 'GET',
+            path: '/api/market/orders',
+            handler: 'market.listOrders',
+            middleware: ['auth', 'permission:market:orders'],
+            description: 'List all orders',
+        },
+        {
+            method: 'POST',
+            path: '/api/market/coupons/validate',
+            handler: 'market.validateCoupon',
+            description: 'Validate a coupon code (public)',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'product-card',
+            name: 'Product Card',
+            category: 'commerce',
+            component: 'MarketProductCard',
+            settingsSchema: z.object({
+                productId: z.string().optional(),
+                showPrice: z.boolean().default(true),
+                showAddToCart: z.boolean().default(true),
+                showRating: z.boolean().default(false),
+                imageAspectRatio: z.enum(['square', 'portrait', 'landscape']).default('square'),
+            }),
+        },
+        {
+            type: 'product-grid',
+            name: 'Product Grid',
+            category: 'commerce',
+            component: 'MarketProductGrid',
+            settingsSchema: z.object({
+                category: z.string().optional(),
+                limit: z.number().min(1).max(24).default(8),
+                columns: z.number().min(1).max(6).default(4),
+                sortBy: z.enum(['price-asc', 'price-desc', 'newest', 'name', 'popular']).default('newest'),
+                showFilters: z.boolean().default(true),
+            }),
+        },
+        {
+            type: 'cart-widget',
+            name: 'Shopping Cart',
+            category: 'commerce',
+            component: 'MarketCartWidget',
+            settingsSchema: z.object({
+                style: z.enum(['mini', 'full', 'dropdown']).default('mini'),
+                showItemCount: z.boolean().default(true),
+            }),
+        },
+        {
+            type: 'checkout-button',
+            name: 'Checkout Button',
+            category: 'commerce',
+            component: 'MarketCheckoutButton',
+            settingsSchema: z.object({
+                text: z.string().default('Proceed to Checkout'),
+                style: z.enum(['primary', 'accent', 'outline']).default('primary'),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'market-revenue',
+            name: 'Store Revenue',
+            component: 'MarketRevenueWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 2 },
+        },
+        {
+            id: 'market-recent-orders',
+            name: 'Recent Orders',
+            component: 'MarketRecentOrdersWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+        {
+            id: 'market-top-products',
+            name: 'Top Products',
+            component: 'MarketTopProductsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 3 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'product') {
+                    const product = payload.content;
+                    // Generate slug from name
+                    if (product.name && !product.slug) {
+                        product.slug = product.name
+                            .toLowerCase()
+                            .replace(/[^a-z0-9]+/g, '-')
+                            .replace(/^-|-$/g, '');
+                    }
+                    // Validate pricing
+                    if (typeof product.price === 'number' && product.price < 0) {
+                        throw new Error('Market: Product price cannot be negative');
+                    }
+                    // Calculate sale savings
+                    if (product.salePrice && product.price) {
+                        product.savingsPercent = Math.round(((product.price - product.salePrice) / product.price) * 100);
+                    }
+                }
+                // Order validation
+                if (payload.content?.type === 'order') {
+                    const order = payload.content;
+                    if (!order.items || order.items.length === 0) {
+                        throw new Error('Market: Order must have at least one item');
+                    }
+                    // Calculate order totals
+                    let subtotal = 0;
+                    for (const item of order.items) {
+                        item.lineTotal = (item.price ?? 0) * (item.quantity ?? 1);
+                        subtotal += item.lineTotal;
+                    }
+                    order.subtotal = subtotal;
+                    order.discount = order._couponDiscount ?? 0;
+                    order.shipping = order.shippingCost ?? 0;
+                    order.tax = (subtotal - order.discount) * (order.taxRate ?? 0);
+                    order.total = subtotal - order.discount + order.shipping + order.tax;
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'order' && payload.content?.status === 'paid') {
+                    // Trigger order confirmation notification and stock deduction
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        currency: z.string().default('GBP'),
+        currencySymbol: z.string().default('£'),
+        taxRate: z.number().min(0).max(1).default(0.2),
+        taxInclusive: z.boolean().default(true),
+        enableCoupons: z.boolean().default(true),
+        enableShipping: z.boolean().default(false),
+        freeShippingThreshold: z.number().optional(),
+        stripePublishableKey: z.string().optional(),
+        stripeSecretKey: z.string().optional(),
+        stripeWebhookSecret: z.string().optional(),
+        lowStockThreshold: z.number().default(5),
+        enableReviews: z.boolean().default(false),
+        enableDigitalProducts: z.boolean().default(false),
+    }),
+    async onActivate(core) {
+        // Wire orders to invoicing via ledger
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'order' && payload.content?.status === 'paid') {
+                if (core.plugins.isActive('@foundry/ledger')) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'invoice',
+                            action: 'generate_from_order',
+                            orderId: payload.content.id,
+                            customerEmail: payload.content.customerEmail,
+                            lineItems: payload.content.items,
+                            total: payload.content.total,
+                            status: 'paid',
+                            paidAt: new Date().toISOString(),
+                        },
+                    });
+                }
+                // Wire to inventory if depot is active
+                if (core.plugins.isActive('@foundry/depot')) {
+                    for (const item of payload.content.items ?? []) {
+                        if (item.inventoryItemId) {
+                            core.hooks.emit('content:before_save', {
+                                content: {
+                                    type: 'inventory_item',
+                                    id: item.inventoryItemId,
+                                    stockQuantity: -item.quantity,
+                                    _adjustment: true,
+                                    reason: `Order ${payload.content.id}`,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+// ---------------------------------------------------------------------------
+// Sentinel — Monitoring & Health Checks
+// ---------------------------------------------------------------------------
+export const sentinelPlugin = {
+    id: '@foundry/sentinel',
+    name: 'Sentinel',
+    version: '1.0.0',
+    description: 'Site monitoring with health checks, uptime tracking, error logging, and alert notifications',
+    adminPages: [
+        {
+            path: 'sentinel',
+            label: 'Monitoring',
+            icon: 'shield',
+            component: 'SentinelDashboardPage',
+            order: 50,
+            permission: 'sentinel:view',
+            children: [
+                {
+                    path: 'health',
+                    label: 'Health',
+                    component: 'SentinelHealthPage',
+                    permission: 'sentinel:view',
+                },
+                {
+                    path: 'uptime',
+                    label: 'Uptime',
+                    component: 'SentinelUptimePage',
+                    permission: 'sentinel:view',
+                },
+                {
+                    path: 'errors',
+                    label: 'Errors',
+                    component: 'SentinelErrorsPage',
+                    permission: 'sentinel:view',
+                },
+                {
+                    path: 'alerts',
+                    label: 'Alerts',
+                    component: 'SentinelAlertsPage',
+                    permission: 'sentinel:manage',
+                },
+                {
+                    path: 'performance',
+                    label: 'Performance',
+                    component: 'SentinelPerformancePage',
+                    permission: 'sentinel:view',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/sentinel/health',
+            handler: 'sentinel.healthCheck',
+            description: 'Run health check (public status endpoint)',
+        },
+        {
+            method: 'GET',
+            path: '/api/sentinel/status',
+            handler: 'sentinel.getStatus',
+            description: 'Get system status page (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/sentinel/errors',
+            handler: 'sentinel.listErrors',
+            middleware: ['auth', 'permission:sentinel:view'],
+            description: 'List recent errors',
+        },
+        {
+            method: 'GET',
+            path: '/api/sentinel/uptime',
+            handler: 'sentinel.getUptime',
+            middleware: ['auth'],
+            description: 'Get uptime history',
+        },
+        {
+            method: 'GET',
+            path: '/api/sentinel/performance',
+            handler: 'sentinel.getPerformance',
+            middleware: ['auth', 'permission:sentinel:view'],
+            description: 'Get performance metrics',
+        },
+        {
+            method: 'POST',
+            path: '/api/sentinel/alerts',
+            handler: 'sentinel.createAlert',
+            middleware: ['auth', 'permission:sentinel:manage'],
+            description: 'Create an alert rule',
+        },
+        {
+            method: 'POST',
+            path: '/api/sentinel/test-alert',
+            handler: 'sentinel.testAlert',
+            middleware: ['auth', 'permission:sentinel:manage'],
+            description: 'Send a test alert notification',
+        },
+    ],
+    widgets: [
+        {
+            id: 'sentinel-status',
+            name: 'System Status',
+            component: 'SentinelStatusWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 2 },
+        },
+        {
+            id: 'sentinel-uptime',
+            name: 'Uptime',
+            component: 'SentinelUptimeWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 2 },
+        },
+        {
+            id: 'sentinel-error-count',
+            name: 'Error Count',
+            component: 'SentinelErrorCountWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 2, height: 1 },
+        },
+        {
+            id: 'sentinel-response-time',
+            name: 'Response Time',
+            component: 'SentinelResponseTimeWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'page:after_render',
+            handler: (payload) => {
+                // Track render performance
+                const renderEnd = Date.now();
+                const renderStart = payload.page?._renderStartTime;
+                if (renderStart) {
+                    const renderTime = renderEnd - renderStart;
+                    _performanceLog.push({
+                        pageId: payload.page?.id,
+                        path: payload.page?.meta?.slug,
+                        renderTimeMs: renderTime,
+                        timestamp: new Date().toISOString(),
+                        htmlSize: payload.html?.length ?? 0,
+                    });
+                    // Keep only last 1000 entries
+                    if (_performanceLog.length > 1000) {
+                        _performanceLog.splice(0, _performanceLog.length - 1000);
+                    }
+                    // Alert if render time exceeds threshold
+                    if (renderTime > 3000) {
+                        _alertQueue.push({
+                            type: 'slow_render',
+                            severity: 'warning',
+                            message: `Page "${payload.page?.meta?.title ?? payload.page?.id}" took ${renderTime}ms to render`,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+                return payload;
+            },
+            priority: 999, // run absolutely last
+        },
+        {
+            hook: 'page:before_render',
+            handler: (payload) => {
+                // Stamp render start time for performance measurement
+                if (payload.page) {
+                    payload.page._renderStartTime = Date.now();
+                }
+                return payload;
+            },
+            priority: 0, // run absolutely first
+        },
+        {
+            hook: 'config:changed',
+            handler: (payload) => {
+                // Log config changes for audit trail
+                _auditLog.push({
+                    type: 'config_change',
+                    key: payload.key,
+                    timestamp: new Date().toISOString(),
+                });
+                if (_auditLog.length > 500) {
+                    _auditLog.splice(0, _auditLog.length - 500);
+                }
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        healthCheckInterval: z.number().min(30).max(3600).default(300),
+        alertChannels: z.array(z.enum(['email', 'sms', 'webhook', 'in-app'])).default(['in-app', 'email']),
+        alertEmail: z.string().email().optional(),
+        alertWebhookUrl: z.string().url().optional(),
+        slowRenderThresholdMs: z.number().min(100).max(30000).default(3000),
+        errorRateAlertThreshold: z.number().min(1).max(100).default(5),
+        enablePerformanceTracking: z.boolean().default(true),
+        retentionDays: z.number().min(7).max(365).default(90),
+        publicStatusPage: z.boolean().default(false),
+        monitoredEndpoints: z.array(z.object({
+            url: z.string(),
+            name: z.string(),
+            interval: z.number().default(300),
+            expectedStatus: z.number().default(200),
+        })).default([]),
+    }),
+    async onActivate(_core) {
+        _performanceLog.length = 0;
+        _alertQueue.length = 0;
+        _auditLog.length = 0;
+    },
+    async onDeactivate(_core) {
+        _performanceLog.length = 0;
+        _alertQueue.length = 0;
+        _auditLog.length = 0;
+    },
+};
+const _performanceLog = [];
+const _alertQueue = [];
+const _auditLog = [];
+//# sourceMappingURL=communication.js.map