feat(backend): add event emissions for user and MCP server actions

Author: Lasim

services/backend/src/events/eventNames.ts

@@ -35,6 +35,9 @@ export const EVENT_NAMES = {
   MCP_INSTALLATION_CREATED: 'mcp.installation_created', // matches mcp.installations.create
   MCP_INSTALLATION_UPDATED: 'mcp.installation_updated', // matches mcp.installations.edit
   MCP_INSTALLATION_DELETED: 'mcp.installation_deleted', // matches mcp.installations.delete
+  MCP_SERVER_CREATED: 'mcp.server_created',             // matches mcp.servers.create
+  MCP_SERVER_UPDATED: 'mcp.server_updated',             // matches mcp.servers.edit
+  MCP_SERVER_DELETED: 'mcp.server_deleted',             // matches mcp.servers.delete
 
   // System Events
   SYSTEM_STARTUP: 'system.startup',

services/backend/src/events/types.ts

@@ -337,6 +337,56 @@ export interface CoreEventData {
     };
   };
 
+  [EVENT_NAMES.MCP_SERVER_CREATED]: {
+    server: {
+      id: string;
+      name: string;
+      description?: string;
+      language: string;
+      runtime: string;
+    };
+    createdBy: {
+      id: string;
+      email: string;
+    };
+    metadata: {
+      ip: string;
+    };
+  };
+
+  [EVENT_NAMES.MCP_SERVER_UPDATED]: {
+    server: {
+      id: string;
+      name: string;
+      description?: string;
+      language: string;
+      runtime: string;
+    };
+    updatedBy: {
+      id: string;
+      email: string;
+    };
+    changes: Record<string, any>;
+    metadata: {
+      ip: string;
+    };
+  };
+
+  [EVENT_NAMES.MCP_SERVER_DELETED]: {
+    server: {
+      id: string;
+      name: string;
+      description?: string;
+    };
+    deletedBy: {
+      id: string;
+      email: string;
+    };
+    metadata: {
+      ip: string;
+    };
+  };
+
   [EVENT_NAMES.SYSTEM_STARTUP]: {
     version: string;
     environment: string;

services/backend/src/routes/auth/loginEmail.ts

@@ -4,6 +4,8 @@ import { verify } from '@node-rs/argon2';
 import { getDb, getSchema } from '../../db';
 import { eq, or } from 'drizzle-orm';
 import { GlobalSettingsInitService } from '../../global-settings';
+import { EVENT_NAMES } from '../../events';
+import type { EventContext } from '../../events/types';
 
 // Reusable Schema Constants
 const LOGIN_REQUEST_SCHEMA = {
@@ -287,6 +289,46 @@ export default async function loginEmailRoute(server: FastifyInstance) {
 
         reply.setCookie(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
 
+        // Emit USER_LOGIN event
+        try {
+          const eventContext: EventContext = {
+            db,
+            logger: server.log,
+            user: {
+              id: user.id,
+              email: user.email,
+              roleId: user.role_id
+            },
+            request: {
+              ip: request.ip,
+              userAgent: request.headers['user-agent'],
+              requestId: request.id
+            },
+            timestamp: new Date()
+          };
+
+          server.eventBus.emitWithContext(
+            EVENT_NAMES.USER_LOGIN,
+            {
+              user: {
+                id: user.id,
+                email: user.email,
+                name: user.username || `${user.first_name || ''} ${user.last_name || ''}`.trim() || user.email
+              },
+              metadata: {
+                loginMethod: 'email',
+                ip: request.ip,
+                userAgent: request.headers['user-agent']
+              }
+            },
+            eventContext
+          );
+          server.log.info(`USER_LOGIN event emitted for user: ${user.id}`);
+        } catch (eventError) {
+          server.log.error(eventError, `Failed to emit USER_LOGIN event for user ${user.id}:`);
+          // Don't fail login if event emission fails
+        }
+        
         // Create clean response object to avoid serialization issues
         const cleanResponse: LoginSuccessResponse = {
           success: true,

services/backend/src/routes/auth/logout.ts

@@ -1,10 +1,13 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
 import { getLucia } from '../../lib/lucia';
 import { getDb, getSchema, getDbStatus } from '../../db';
 import { eq } from 'drizzle-orm';
 import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { z } from 'zod';
 import { createSchema } from 'zod-openapi';
+import { EVENT_NAMES } from '../../events';
+import type { EventContext } from '../../events/types';
 
 // Zod schema for the logout response
 const logoutResponseSchema = z.object({
@@ -58,7 +61,7 @@ export default async function logoutRoute(fastify: FastifyInstance) {
             if (authSessionTable && authSessionTable.id) {
               const dbStatus = getDbStatus();
               if (dbStatus.dialect === 'sqlite') {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                 
                 const sqliteDb = db as BetterSQLite3Database<any>;
                 await sqliteDb.delete(authSessionTable).where(eq(authSessionTable.id, sessionId));
               }
@@ -94,6 +97,67 @@ export default async function logoutRoute(fastify: FastifyInstance) {
         reply.setCookie(blankCookie.name, blankCookie.value, blankCookie.attributes);
         fastify.log.info('Blank cookie sent to clear client session');
 
+        // Emit USER_LOGOUT event
+        try {
+          if (request.user) {
+            // Get user role from database since it's not in the session
+            const db = getDb();
+            const schema = getSchema();
+            const authUserTable = schema.authUser;
+            let userRole = 'unknown';
+            
+            try {
+              const userResult = await (db as any)
+                .select({ role_id: authUserTable.role_id })
+                .from(authUserTable)
+                .where(eq(authUserTable.id, request.user.id))
+                .limit(1);
+              
+              if (userResult.length > 0) {
+                userRole = userResult[0].role_id;
+              }
+            } catch (roleError) {
+              fastify.log.warn(roleError, 'Failed to fetch user role for logout event');
+            }
+
+            const eventContext: EventContext = {
+              db,
+              logger: fastify.log,
+              user: {
+                id: request.user.id,
+                email: (request.user as any).email,
+                roleId: userRole
+              },
+              request: {
+                ip: request.ip,
+                userAgent: request.headers['user-agent'],
+                requestId: request.id
+              },
+              timestamp: new Date()
+            };
+
+            fastify.eventBus.emitWithContext(
+              EVENT_NAMES.USER_LOGOUT,
+              {
+                user: {
+                  id: request.user.id,
+                  email: (request.user as any).email,
+                  name: (request.user as any).username || `${(request.user as any).firstName || ''} ${(request.user as any).lastName || ''}`.trim() || (request.user as any).email
+                },
+                metadata: {
+                  ip: request.ip,
+                  userAgent: request.headers['user-agent']
+                }
+              },
+              eventContext
+            );
+            fastify.log.info(`USER_LOGOUT event emitted for user: ${request.user.id}`);
+          }
+        } catch (eventError) {
+          fastify.log.error(eventError, 'Failed to emit USER_LOGOUT event:');
+          // Don't fail logout if event emission fails
+        }
+        
         const response = { success: true, message: 'Logged out successfully.' };
         const jsonString = JSON.stringify(response);
         return reply.status(200).type('application/json').send(jsonString);
@@ -112,7 +176,7 @@ export default async function logoutRoute(fastify: FastifyInstance) {
           if (authSessionTable && authSessionTable.id) {
             const dbStatus = getDbStatus();
             if (dbStatus.dialect === 'sqlite') {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+               
               const sqliteDb = db as BetterSQLite3Database<any>;
               await sqliteDb.delete(authSessionTable).where(eq(authSessionTable.id, sessionId));
             }

services/backend/src/routes/auth/registerEmail.ts

@@ -7,6 +7,8 @@ import { hash } from '@node-rs/argon2';
 import { TeamService } from '../../services/teamService';
 import { GlobalSettingsInitService } from '../../global-settings';
 import { UserPreferencesService } from '../../services/UserPreferencesService';
+import { EVENT_NAMES } from '../../events';
+import type { EventContext } from '../../events/types';
 
 // Reusable Schema Constants
 const REGISTER_EMAIL_REQUEST_SCHEMA = {
@@ -347,6 +349,47 @@ export default async function registerEmailRoute(server: FastifyInstance) {
         // Get the created user data
         const user = createdUser[0];
 
+        // Emit USER_REGISTERED event
+        try {
+          const eventContext: EventContext = {
+            db,
+            logger: server.log,
+            user: {
+              id: user.id,
+              email: user.email,
+              roleId: user.role_id
+            },
+            request: {
+              ip: request.ip,
+              userAgent: request.headers['user-agent'],
+              requestId: request.id
+            },
+            timestamp: new Date()
+          };
+
+          server.eventBus.emitWithContext(
+            EVENT_NAMES.USER_REGISTERED,
+            {
+              user: {
+                id: user.id,
+                email: user.email,
+                name: user.username || `${user.first_name || ''} ${user.last_name || ''}`.trim() || user.email,
+                createdAt: new Date()
+              },
+              metadata: {
+                registrationMethod: 'email',
+                ip: request.ip,
+                userAgent: request.headers['user-agent']
+              }
+            },
+            eventContext
+          );
+          server.log.info(`USER_REGISTERED event emitted for user: ${user.id}`);
+        } catch (eventError) {
+          server.log.error(eventError, `Failed to emit USER_REGISTERED event for user ${user.id}:`);
+          // Don't fail registration if event emission fails
+        }
+
         // Customize message based on email verification status
         let message = 'User registered successfully.';
         if (isFirstUser) {

services/backend/src/routes/mcp/installations/create.ts

@@ -16,6 +16,8 @@ import {
   type InstallationSuccessResponse,
   type ErrorResponse
 } from './schemas';
+import { EVENT_NAMES } from '../../../events';
+import type { EventContext } from '../../../events/types';
 
 export default async function createInstallationRoute(server: FastifyInstance) {
   server.post('/teams/:teamId/mcp/installations', {
@@ -99,6 +101,50 @@ export default async function createInstallationRoute(server: FastifyInstance) {
         serverId: installationData.server_id
       }, 'MCP server installation created successfully');
 
+      // Emit MCP_INSTALLATION_CREATED event
+      try {
+        const eventContext: EventContext = {
+          db,
+          logger: request.log,
+          user: {
+            id: userId,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            email: (request.user as any).email,
+            roleId: 'unknown'
+          },
+          request: {
+            ip: request.ip,
+            userAgent: request.headers['user-agent'],
+            requestId: request.id
+          },
+          timestamp: new Date()
+        };
+
+        server.eventBus.emitWithContext(
+          EVENT_NAMES.MCP_INSTALLATION_CREATED,
+          {
+            installation: {
+              id: installation.id,
+              serverId: installation.server_id,
+              teamId: teamId
+            },
+            installedBy: {
+              id: userId,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              email: (request.user as any).email
+            },
+            metadata: {
+              ip: request.ip
+            }
+          },
+          eventContext
+        );
+        request.log.info(`MCP_INSTALLATION_CREATED event emitted for installation: ${installation.id}`);
+      } catch (eventError) {
+        request.log.error(eventError, `Failed to emit MCP_INSTALLATION_CREATED event for installation ${installation.id}:`);
+        // Don't fail installation creation if event emission fails
+      }
+
       const response: InstallationSuccessResponse = {
         success: true,
         data: formatInstallationResponse(installation)