foundrycms 0.1.0

package/dist/plugins/operations.js

@@ -0,0 +1,930 @@
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Roster — Appointments
+// ---------------------------------------------------------------------------
+export const rosterPlugin = {
+    id: '@foundry/roster',
+    name: 'Roster',
+    version: '1.0.0',
+    description: 'Appointment scheduling with booking widget, calendar sync, reminders, and timezone handling',
+    adminPages: [
+        {
+            path: 'roster',
+            label: 'Appointments',
+            icon: 'calendar',
+            component: 'RosterDashboardPage',
+            order: 30,
+            permission: 'roster:view',
+            children: [
+                {
+                    path: 'calendar',
+                    label: 'Calendar',
+                    component: 'RosterCalendarPage',
+                    permission: 'roster:view',
+                },
+                {
+                    path: 'bookings',
+                    label: 'Bookings',
+                    component: 'RosterBookingsPage',
+                    permission: 'roster:view',
+                },
+                {
+                    path: 'availability',
+                    label: 'Availability',
+                    component: 'RosterAvailabilityPage',
+                    permission: 'roster:manage',
+                },
+                {
+                    path: 'services',
+                    label: 'Services',
+                    component: 'RosterServicesPage',
+                    permission: 'roster:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/roster/availability',
+            handler: 'roster.getAvailability',
+            description: 'Get available time slots for a date range (public)',
+        },
+        {
+            method: 'POST',
+            path: '/api/roster/bookings',
+            handler: 'roster.createBooking',
+            description: 'Create a new booking (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/roster/bookings',
+            handler: 'roster.listBookings',
+            middleware: ['auth', 'permission:roster:view'],
+            description: 'List all bookings',
+        },
+        {
+            method: 'PATCH',
+            path: '/api/roster/bookings/:id',
+            handler: 'roster.updateBooking',
+            middleware: ['auth', 'permission:roster:manage'],
+            description: 'Update a booking (confirm, cancel, reschedule)',
+        },
+        {
+            method: 'DELETE',
+            path: '/api/roster/bookings/:id',
+            handler: 'roster.cancelBooking',
+            middleware: ['auth'],
+            description: 'Cancel a booking',
+        },
+        {
+            method: 'GET',
+            path: '/api/roster/services',
+            handler: 'roster.listServices',
+            description: 'List bookable services (public)',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'booking-widget',
+            name: 'Booking Widget',
+            category: 'interactive',
+            component: 'RosterBookingWidget',
+            settingsSchema: z.object({
+                serviceId: z.string().optional(),
+                showAllServices: z.boolean().default(true),
+                theme: z.enum(['light', 'dark', 'auto']).default('auto'),
+                primaryColor: z.string().default('#6366f1'),
+                showTimezone: z.boolean().default(true),
+                maxAdvanceDays: z.number().min(1).max(365).default(60),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'roster-upcoming',
+            name: 'Upcoming Appointments',
+            component: 'RosterUpcomingWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+        {
+            id: 'roster-today',
+            name: "Today's Schedule",
+            component: 'RosterTodayWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 4 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'booking') {
+                    // Validate booking times
+                    const start = new Date(payload.content.startTime);
+                    const end = new Date(payload.content.endTime);
+                    if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+                        throw new Error('Roster: Invalid booking time format');
+                    }
+                    if (end <= start) {
+                        throw new Error('Roster: End time must be after start time');
+                    }
+                    if (start < new Date()) {
+                        throw new Error('Roster: Cannot book in the past');
+                    }
+                    // Calculate duration in minutes
+                    payload.content.durationMinutes = Math.round((end.getTime() - start.getTime()) / 60000);
+                    // Set status
+                    if (!payload.content.status) {
+                        payload.content.status = 'pending';
+                    }
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'booking' && payload.content?.status === 'confirmed') {
+                    // Queue reminder notifications
+                    // This would connect to the relay plugin for email/SMS
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        timezone: z.string().default('Europe/London'),
+        slotDuration: z.number().min(5).max(480).default(30),
+        bufferBetweenSlots: z.number().min(0).max(60).default(10),
+        workingHours: z.object({
+            monday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '09:00', end: '17:00', enabled: true }),
+            tuesday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '09:00', end: '17:00', enabled: true }),
+            wednesday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '09:00', end: '17:00', enabled: true }),
+            thursday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '09:00', end: '17:00', enabled: true }),
+            friday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '09:00', end: '17:00', enabled: true }),
+            saturday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '10:00', end: '14:00', enabled: false }),
+            sunday: z.object({ start: z.string(), end: z.string(), enabled: z.boolean() }).default({ start: '10:00', end: '14:00', enabled: false }),
+        }).default({}),
+        requireConfirmation: z.boolean().default(true),
+        sendReminders: z.boolean().default(true),
+        reminderHoursBefore: z.number().default(24),
+        maxBookingsPerDay: z.number().min(1).max(100).default(20),
+    }),
+    async onActivate(core) {
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'booking' && payload.content?.status === 'confirmed') {
+                // Auto-create CRM contact from booking if compass is active
+                if (core.plugins.isActive('@foundry/compass') && payload.content.clientEmail) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'contact',
+                            email: payload.content.clientEmail,
+                            name: payload.content.clientName,
+                            source: 'booking',
+                            lifecycleStage: 'lead',
+                        },
+                    });
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+// ---------------------------------------------------------------------------
+// Depot — Inventory Management
+// ---------------------------------------------------------------------------
+export const depotPlugin = {
+    id: '@foundry/depot',
+    name: 'Depot',
+    version: '1.0.0',
+    description: 'Inventory management with stock tracking, low-stock alerts, suppliers, and purchase orders',
+    adminPages: [
+        {
+            path: 'depot',
+            label: 'Inventory',
+            icon: 'package',
+            component: 'DepotDashboardPage',
+            order: 35,
+            permission: 'depot:view',
+            children: [
+                {
+                    path: 'items',
+                    label: 'Items',
+                    component: 'DepotItemsPage',
+                    permission: 'depot:view',
+                },
+                {
+                    path: 'items/:id',
+                    label: 'Item Detail',
+                    component: 'DepotItemDetailPage',
+                    permission: 'depot:view',
+                },
+                {
+                    path: 'categories',
+                    label: 'Categories',
+                    component: 'DepotCategoriesPage',
+                    permission: 'depot:manage',
+                },
+                {
+                    path: 'suppliers',
+                    label: 'Suppliers',
+                    component: 'DepotSuppliersPage',
+                    permission: 'depot:manage',
+                },
+                {
+                    path: 'orders',
+                    label: 'Purchase Orders',
+                    component: 'DepotOrdersPage',
+                    permission: 'depot:orders',
+                },
+                {
+                    path: 'stock-adjustments',
+                    label: 'Adjustments',
+                    component: 'DepotAdjustmentsPage',
+                    permission: 'depot:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/depot/items',
+            handler: 'depot.listItems',
+            middleware: ['auth'],
+            description: 'List inventory items with filters',
+        },
+        {
+            method: 'POST',
+            path: '/api/depot/items',
+            handler: 'depot.createItem',
+            middleware: ['auth', 'permission:depot:manage'],
+            description: 'Add new inventory item',
+        },
+        {
+            method: 'PATCH',
+            path: '/api/depot/items/:id/stock',
+            handler: 'depot.adjustStock',
+            middleware: ['auth', 'permission:depot:manage'],
+            description: 'Adjust stock level for an item',
+        },
+        {
+            method: 'GET',
+            path: '/api/depot/low-stock',
+            handler: 'depot.getLowStock',
+            middleware: ['auth'],
+            description: 'Get items below minimum stock threshold',
+        },
+        {
+            method: 'POST',
+            path: '/api/depot/purchase-orders',
+            handler: 'depot.createPurchaseOrder',
+            middleware: ['auth', 'permission:depot:orders'],
+            description: 'Create a purchase order',
+        },
+    ],
+    widgets: [
+        {
+            id: 'depot-stock-summary',
+            name: 'Stock Summary',
+            component: 'DepotStockSummaryWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 3, height: 2 },
+        },
+        {
+            id: 'depot-low-stock-alerts',
+            name: 'Low Stock Alerts',
+            component: 'DepotLowStockWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 3 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'inventory_item') {
+                    // Validate SKU format
+                    if (payload.content.sku && !/^[A-Z0-9\-]{3,30}$/i.test(payload.content.sku)) {
+                        throw new Error('Depot: SKU must be 3-30 alphanumeric characters or hyphens');
+                    }
+                    // Ensure non-negative stock
+                    if (typeof payload.content.stockQuantity === 'number' && payload.content.stockQuantity < 0) {
+                        throw new Error('Depot: Stock quantity cannot be negative');
+                    }
+                    // Track stock changes
+                    if (payload.content._previousQuantity !== undefined) {
+                        payload.content._stockChange = payload.content.stockQuantity - payload.content._previousQuantity;
+                    }
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'inventory_item') {
+                    const item = payload.content;
+                    // Check for low stock alert
+                    if (item.stockQuantity <= (item.minimumStock ?? 0)) {
+                        // This would trigger a notification via the relay plugin
+                    }
+                }
+            },
+            priority: 10,
+        },
+    ],
+    settingsSchema: z.object({
+        defaultMinimumStock: z.number().min(0).default(5),
+        enableLowStockAlerts: z.boolean().default(true),
+        lowStockNotifyEmail: z.string().email().optional(),
+        trackCostPrice: z.boolean().default(true),
+        enableBarcodes: z.boolean().default(false),
+        defaultUnit: z.string().default('units'),
+        stockValuationMethod: z.enum(['fifo', 'lifo', 'average']).default('average'),
+    }),
+    async onActivate(core) {
+        // Wire up stock deduction when market plugin sells a product
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'order' && payload.content?.status === 'paid') {
+                // Deduct stock for each order line item
+                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, // relative adjustment
+                                _adjustment: true,
+                                reason: `Order ${payload.content.id}`,
+                            },
+                        });
+                    }
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+// ---------------------------------------------------------------------------
+// Stage — Events
+// ---------------------------------------------------------------------------
+export const stagePlugin = {
+    id: '@foundry/stage',
+    name: 'Stage',
+    version: '1.0.0',
+    description: 'Event management with ticketing, RSVP, event pages, and attendee tracking',
+    adminPages: [
+        {
+            path: 'stage',
+            label: 'Events',
+            icon: 'calendar-check',
+            component: 'StageDashboardPage',
+            order: 32,
+            permission: 'stage:view',
+            children: [
+                {
+                    path: 'events',
+                    label: 'All Events',
+                    component: 'StageEventsPage',
+                    permission: 'stage:view',
+                },
+                {
+                    path: 'events/new',
+                    label: 'Create Event',
+                    component: 'StageEventEditorPage',
+                    permission: 'stage:create',
+                },
+                {
+                    path: 'attendees',
+                    label: 'Attendees',
+                    component: 'StageAttendeesPage',
+                    permission: 'stage:view',
+                },
+                {
+                    path: 'tickets',
+                    label: 'Ticket Types',
+                    component: 'StageTicketsPage',
+                    permission: 'stage:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/stage/events',
+            handler: 'stage.listEvents',
+            description: 'List upcoming events (public)',
+        },
+        {
+            method: 'GET',
+            path: '/api/stage/events/:slug',
+            handler: 'stage.getEvent',
+            description: 'Get event details by slug (public)',
+        },
+        {
+            method: 'POST',
+            path: '/api/stage/events',
+            handler: 'stage.createEvent',
+            middleware: ['auth', 'permission:stage:create'],
+            description: 'Create a new event',
+        },
+        {
+            method: 'POST',
+            path: '/api/stage/events/:id/rsvp',
+            handler: 'stage.rsvp',
+            description: 'RSVP to an event (public)',
+        },
+        {
+            method: 'POST',
+            path: '/api/stage/events/:id/tickets/purchase',
+            handler: 'stage.purchaseTicket',
+            description: 'Purchase tickets for an event',
+        },
+        {
+            method: 'GET',
+            path: '/api/stage/events/:id/attendees',
+            handler: 'stage.listAttendees',
+            middleware: ['auth', 'permission:stage:view'],
+            description: 'List event attendees',
+        },
+    ],
+    pageElements: [
+        {
+            type: 'event-card',
+            name: 'Event Card',
+            category: 'content',
+            component: 'StageEventCard',
+            settingsSchema: z.object({
+                eventId: z.string().optional(),
+                showDate: z.boolean().default(true),
+                showLocation: z.boolean().default(true),
+                showTicketPrice: z.boolean().default(true),
+                showAvailability: z.boolean().default(true),
+                ctaText: z.string().default('Register Now'),
+            }),
+        },
+        {
+            type: 'event-list',
+            name: 'Event List',
+            category: 'content',
+            component: 'StageEventList',
+            settingsSchema: z.object({
+                limit: z.number().min(1).max(20).default(6),
+                layout: z.enum(['grid', 'list', 'timeline']).default('grid'),
+                showPast: z.boolean().default(false),
+                category: z.string().optional(),
+            }),
+        },
+    ],
+    widgets: [
+        {
+            id: 'stage-upcoming-events',
+            name: 'Upcoming Events',
+            component: 'StageUpcomingEventsWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 4, height: 3 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'event') {
+                    const event = payload.content;
+                    // Validate event dates
+                    if (event.startDate && event.endDate) {
+                        const start = new Date(event.startDate);
+                        const end = new Date(event.endDate);
+                        if (end < start) {
+                            throw new Error('Stage: Event end date must be after start date');
+                        }
+                    }
+                    // Generate slug
+                    if (event.title && !event.slug) {
+                        event.slug = event.title
+                            .toLowerCase()
+                            .replace(/[^a-z0-9]+/g, '-')
+                            .replace(/^-|-$/g, '');
+                    }
+                    // Calculate ticket availability
+                    if (event.ticketTypes) {
+                        event.totalCapacity = event.ticketTypes.reduce((sum, t) => sum + (t.maxQuantity ?? 0), 0);
+                        event.ticketsSold = event.ticketTypes.reduce((sum, t) => sum + (t.sold ?? 0), 0);
+                        event.ticketsAvailable = event.totalCapacity - event.ticketsSold;
+                    }
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        defaultTimezone: z.string().default('Europe/London'),
+        enableTicketing: z.boolean().default(true),
+        enableRsvp: z.boolean().default(true),
+        requireApproval: z.boolean().default(false),
+        maxAttendeesDefault: z.number().min(1).default(100),
+        sendConfirmationEmail: z.boolean().default(true),
+        calendarExport: z.boolean().default(true),
+    }),
+    async onActivate(core) {
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'event_registration') {
+                // Update attendee count and trigger confirmation
+                if (core.plugins.isActive('@foundry/compass')) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'contact',
+                            email: payload.content.attendeeEmail,
+                            name: payload.content.attendeeName,
+                            source: 'event',
+                            lifecycleStage: 'lead',
+                        },
+                    });
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+// ---------------------------------------------------------------------------
+// Blueprint — Project Management
+// ---------------------------------------------------------------------------
+export const blueprintPlugin = {
+    id: '@foundry/blueprint',
+    name: 'Blueprint',
+    version: '1.0.0',
+    description: 'Project management with task boards, time tracking, milestones, and client project portals',
+    adminPages: [
+        {
+            path: 'blueprint',
+            label: 'Projects',
+            icon: 'layout',
+            component: 'BlueprintDashboardPage',
+            order: 12,
+            permission: 'blueprint:view',
+            children: [
+                {
+                    path: 'projects',
+                    label: 'All Projects',
+                    component: 'BlueprintProjectsPage',
+                    permission: 'blueprint:view',
+                },
+                {
+                    path: 'projects/:id',
+                    label: 'Project Detail',
+                    component: 'BlueprintProjectDetailPage',
+                    permission: 'blueprint:view',
+                },
+                {
+                    path: 'board',
+                    label: 'Task Board',
+                    component: 'BlueprintBoardPage',
+                    permission: 'blueprint:view',
+                },
+                {
+                    path: 'time-tracking',
+                    label: 'Time Tracking',
+                    component: 'BlueprintTimeTrackingPage',
+                    permission: 'blueprint:time',
+                },
+                {
+                    path: 'milestones',
+                    label: 'Milestones',
+                    component: 'BlueprintMilestonesPage',
+                    permission: 'blueprint:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/blueprint/projects',
+            handler: 'blueprint.listProjects',
+            middleware: ['auth'],
+            description: 'List all projects',
+        },
+        {
+            method: 'POST',
+            path: '/api/blueprint/projects',
+            handler: 'blueprint.createProject',
+            middleware: ['auth', 'permission:blueprint:create'],
+            description: 'Create a new project',
+        },
+        {
+            method: 'GET',
+            path: '/api/blueprint/projects/:id/tasks',
+            handler: 'blueprint.listTasks',
+            middleware: ['auth'],
+            description: 'List tasks for a project',
+        },
+        {
+            method: 'POST',
+            path: '/api/blueprint/tasks',
+            handler: 'blueprint.createTask',
+            middleware: ['auth', 'permission:blueprint:edit'],
+            description: 'Create a task',
+        },
+        {
+            method: 'PATCH',
+            path: '/api/blueprint/tasks/:id',
+            handler: 'blueprint.updateTask',
+            middleware: ['auth', 'permission:blueprint:edit'],
+            description: 'Update a task (status, assignment, etc.)',
+        },
+        {
+            method: 'POST',
+            path: '/api/blueprint/time-entries',
+            handler: 'blueprint.logTime',
+            middleware: ['auth', 'permission:blueprint:time'],
+            description: 'Log time against a task',
+        },
+        {
+            method: 'GET',
+            path: '/api/blueprint/time-entries',
+            handler: 'blueprint.listTimeEntries',
+            middleware: ['auth'],
+            description: 'List time entries with filters',
+        },
+    ],
+    widgets: [
+        {
+            id: 'blueprint-active-projects',
+            name: 'Active Projects',
+            component: 'BlueprintActiveProjectsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 3 },
+        },
+        {
+            id: 'blueprint-my-tasks',
+            name: 'My Tasks',
+            component: 'BlueprintMyTasksWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 4 },
+        },
+        {
+            id: 'blueprint-time-summary',
+            name: 'Time This Week',
+            component: 'BlueprintTimeSummaryWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 2, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:before_save',
+            handler: (payload) => {
+                if (payload.content?.type === 'task') {
+                    const task = payload.content;
+                    // Validate priority
+                    if (task.priority && !['low', 'medium', 'high', 'urgent'].includes(task.priority)) {
+                        throw new Error('Blueprint: Invalid task priority');
+                    }
+                    // Auto-set due date based on project milestone if not set
+                    if (!task.dueDate && task.milestoneId) {
+                        task._inheritMilestoneDueDate = true;
+                    }
+                    // Track status transitions
+                    if (task._previousStatus && task.status !== task._previousStatus) {
+                        task._statusChangedAt = new Date().toISOString();
+                        if (task.status === 'done') {
+                            task.completedAt = new Date().toISOString();
+                        }
+                    }
+                }
+                // Time entry validation
+                if (payload.content?.type === 'time_entry') {
+                    const entry = payload.content;
+                    if (!entry.taskId && !entry.projectId) {
+                        throw new Error('Blueprint: Time entry must be linked to a task or project');
+                    }
+                    if (typeof entry.minutes !== 'number' || entry.minutes <= 0) {
+                        throw new Error('Blueprint: Time entry must have positive minutes');
+                    }
+                    entry.hours = Math.round((entry.minutes / 60) * 100) / 100;
+                }
+                return payload;
+            },
+            priority: 5,
+        },
+    ],
+    settingsSchema: z.object({
+        taskStatuses: z.array(z.object({
+            id: z.string(),
+            label: z.string(),
+            color: z.string(),
+        })).default([
+            { id: 'backlog', label: 'Backlog', color: '#94a3b8' },
+            { id: 'todo', label: 'To Do', color: '#6366f1' },
+            { id: 'in-progress', label: 'In Progress', color: '#f59e0b' },
+            { id: 'review', label: 'Review', color: '#8b5cf6' },
+            { id: 'done', label: 'Done', color: '#22c55e' },
+        ]),
+        defaultView: z.enum(['board', 'list', 'timeline']).default('board'),
+        enableTimeTracking: z.boolean().default(true),
+        hourlyRate: z.number().min(0).default(150),
+        currency: z.string().default('GBP'),
+        enableClientPortal: z.boolean().default(false),
+    }),
+    async onActivate(core) {
+        // Wire up project completion to invoicing
+        core.hooks.on('content:after_save', (payload) => {
+            if (payload.content?.type === 'project' && payload.content?.status === 'completed') {
+                // If ledger plugin is active, prompt for final invoice generation
+                if (core.plugins.isActive('@foundry/ledger')) {
+                    core.hooks.emit('content:before_save', {
+                        content: {
+                            type: 'invoice',
+                            action: 'generate_from_project',
+                            projectId: payload.content.id,
+                            clientId: payload.content.clientId,
+                        },
+                    });
+                }
+            }
+        });
+    },
+    async onDeactivate(_core) { },
+};
+// ---------------------------------------------------------------------------
+// Pulse — Team Dashboard
+// ---------------------------------------------------------------------------
+export const pulsePlugin = {
+    id: '@foundry/pulse',
+    name: 'Pulse',
+    version: '1.0.0',
+    description: 'Team dashboard with status updates, activity feed, announcements, and KPI widgets',
+    adminPages: [
+        {
+            path: 'pulse',
+            label: 'Team',
+            icon: 'activity',
+            component: 'PulseDashboardPage',
+            order: 40,
+            permission: 'pulse:view',
+            children: [
+                {
+                    path: 'feed',
+                    label: 'Activity Feed',
+                    component: 'PulseFeedPage',
+                    permission: 'pulse:view',
+                },
+                {
+                    path: 'status',
+                    label: 'Team Status',
+                    component: 'PulseStatusPage',
+                    permission: 'pulse:view',
+                },
+                {
+                    path: 'announcements',
+                    label: 'Announcements',
+                    component: 'PulseAnnouncementsPage',
+                    permission: 'pulse:announce',
+                },
+                {
+                    path: 'kpis',
+                    label: 'KPIs',
+                    component: 'PulseKpisPage',
+                    permission: 'pulse:manage',
+                },
+            ],
+        },
+    ],
+    apiRoutes: [
+        {
+            method: 'GET',
+            path: '/api/pulse/feed',
+            handler: 'pulse.getFeed',
+            middleware: ['auth'],
+            description: 'Get team activity feed',
+        },
+        {
+            method: 'POST',
+            path: '/api/pulse/status',
+            handler: 'pulse.updateStatus',
+            middleware: ['auth'],
+            description: 'Update your team status',
+        },
+        {
+            method: 'GET',
+            path: '/api/pulse/status',
+            handler: 'pulse.getTeamStatus',
+            middleware: ['auth'],
+            description: 'Get all team member statuses',
+        },
+        {
+            method: 'POST',
+            path: '/api/pulse/announcements',
+            handler: 'pulse.createAnnouncement',
+            middleware: ['auth', 'permission:pulse:announce'],
+            description: 'Post a team announcement',
+        },
+        {
+            method: 'GET',
+            path: '/api/pulse/kpis',
+            handler: 'pulse.getKpis',
+            middleware: ['auth'],
+            description: 'Get KPI dashboard data',
+        },
+    ],
+    widgets: [
+        {
+            id: 'pulse-activity-feed',
+            name: 'Activity Feed',
+            component: 'PulseActivityFeedWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 4 },
+        },
+        {
+            id: 'pulse-team-status',
+            name: 'Team Status',
+            component: 'PulseTeamStatusWidget',
+            areas: ['dashboard', 'sidebar'],
+            defaultSize: { width: 3, height: 3 },
+        },
+        {
+            id: 'pulse-announcements',
+            name: 'Announcements',
+            component: 'PulseAnnouncementsWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 4, height: 2 },
+        },
+        {
+            id: 'pulse-kpi-card',
+            name: 'KPI Card',
+            component: 'PulseKpiCardWidget',
+            areas: ['dashboard'],
+            defaultSize: { width: 2, height: 2 },
+        },
+    ],
+    hooks: [
+        {
+            hook: 'content:after_save',
+            handler: (payload) => {
+                // Log all content changes to the activity feed
+                if (payload.content && !payload.content._silent) {
+                    const activity = {
+                        type: 'activity',
+                        action: payload.content._isNew ? 'created' : 'updated',
+                        entityType: payload.content.type,
+                        entityId: payload.content.id,
+                        entityTitle: payload.content.title || payload.content.name || payload.content.id,
+                        userId: payload.content._userId,
+                        timestamp: new Date().toISOString(),
+                    };
+                    // Store activity entry (handled by the Pulse internal store)
+                    _activityBuffer.push(activity);
+                    if (_activityBuffer.length > 100) {
+                        _activityBuffer.shift();
+                    }
+                }
+            },
+            priority: 99, // run late to capture final state
+        },
+        {
+            hook: 'plugin:activated',
+            handler: (payload) => {
+                _activityBuffer.push({
+                    type: 'activity',
+                    action: 'plugin_activated',
+                    entityType: 'plugin',
+                    entityId: payload.plugin.id,
+                    entityTitle: payload.plugin.name,
+                    timestamp: new Date().toISOString(),
+                });
+            },
+            priority: 50,
+        },
+    ],
+    settingsSchema: z.object({
+        feedMaxItems: z.number().min(10).max(500).default(100),
+        enableStatusUpdates: z.boolean().default(true),
+        statusOptions: z.array(z.object({
+            id: z.string(),
+            label: z.string(),
+            emoji: z.string(),
+        })).default([
+            { id: 'available', label: 'Available', emoji: '🟢' },
+            { id: 'busy', label: 'Busy', emoji: '🔴' },
+            { id: 'away', label: 'Away', emoji: '🟡' },
+            { id: 'focus', label: 'Focus Mode', emoji: '🔵' },
+        ]),
+        enableKpis: z.boolean().default(true),
+    }),
+    async onActivate(_core) {
+        // Initialize activity buffer
+        _activityBuffer.length = 0;
+    },
+    async onDeactivate(_core) {
+        _activityBuffer.length = 0;
+    },
+};
+const _activityBuffer = [];
+//# sourceMappingURL=operations.js.map