@principal-ai/control-tower-core 0.1.25 → 0.2.0

package/dist/server/BaseServer.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseServer = void 0;
-const room_js_1 = require("../types/room.js");
 const EventEmitter_js_1 = require("../abstractions/EventEmitter.js");
+const room_js_1 = require("../types/room.js");
 const ExperimentalAPI_js_1 = require("./ExperimentalAPI.js");
 class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
     constructor(config) {
@@ -25,21 +25,24 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
             config: config.experimental || {
                 enableBroadcast: false,
                 warnOnExperimentalUse: true,
-                trackUsageMetrics: false
+                trackUsageMetrics: false,
             },
             logger: console,
             emitMetric: (event) => {
-                void this.emit('experimental_usage', event);
+                void this.emit("experimental_usage", event);
             },
             getClients: () => Array.from(this.clients.values()),
-            sendToClient: (clientId, message) => this.sendToClient(clientId, message)
+            sendToClient: (clientId, message) => this.sendToClient(clientId, message),
         });
         // Determine mode based on configuration
-        this.mode = (config.httpServer || config.webSocketServer) ? 'integration' : 'standalone';
+        this.mode =
+            config.httpServer || config.webSocketServer
+                ? "integration"
+                : "standalone";
         // Connect auth adapter to transport if both exist and transport supports it
         if (this.auth && this.transport) {
             const transportWithAuth = this.transport;
-            if (typeof transportWithAuth.setAuthAdapter === 'function') {
+            if (typeof transportWithAuth.setAuthAdapter === "function") {
                 transportWithAuth.setAuthAdapter(this.auth);
             }
         }
@@ -66,29 +69,29 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                 const changes = await this.presenceManager.processHeartbeats();
                 // Emit presence change events
                 for (const change of changes) {
-                    await this.emit('presence_changed', {
+                    await this.emit("presence_changed", {
                         userId: change.userId,
                         status: change.status,
-                        timestamp: change.timestamp
+                        timestamp: change.timestamp,
                     });
                     // Broadcast presence updates if enabled
                     if (config.broadcastPresenceUpdates) {
                         await this.experimental.broadcastAuthenticated({
-                            type: 'presence:status_changed',
+                            type: "presence:status_changed",
                             payload: {
                                 userId: change.userId,
                                 status: change.status,
                                 previousStatus: change.previousStatus,
-                                reason: change.reason
-                            }
+                                reason: change.reason,
+                            },
                         });
                     }
                 }
             }
             catch (error) {
-                await this.emit('error', {
+                await this.emit("error", {
                     error: error,
-                    context: 'heartbeat_processor'
+                    context: "heartbeat_processor",
                 });
             }
         }, interval);
@@ -104,62 +107,70 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
     }
     // Server Lifecycle
     async start(port) {
-        if (this.mode === 'integration') {
-            throw new Error('Cannot use start() in integration mode. Use initialize() instead.');
+        if (this.mode === "integration") {
+            throw new Error("Cannot use start() in integration mode. Use initialize() instead.");
         }
         if (!port) {
-            throw new Error('Port is required for standalone mode');
+            throw new Error("Port is required for standalone mode");
         }
         if (this.running) {
-            throw new Error('Server is already running');
+            throw new Error("Server is already running");
         }
         try {
-            await this.transport.connect(`ws://localhost:${port}`, { url: `ws://localhost:${port}` });
+            await this.transport.connect(`ws://localhost:${port}`, {
+                url: `ws://localhost:${port}`,
+            });
             this.running = true;
             this.initialized = true;
-            await this.emit('started', { port });
+            await this.emit("started", { port });
         }
         catch (error) {
-            await this.emit('error', { error: error, context: 'server_start' });
+            await this.emit("error", {
+                error: error,
+                context: "server_start",
+            });
             throw error;
         }
     }
     async initialize() {
-        if (this.mode === 'standalone') {
-            throw new Error('Cannot use initialize() in standalone mode. Use start() instead.');
+        if (this.mode === "standalone") {
+            throw new Error("Cannot use initialize() in standalone mode. Use start() instead.");
         }
         if (this.initialized) {
-            throw new Error('Server is already initialized');
+            throw new Error("Server is already initialized");
         }
         try {
             const transport = this.transport;
             if (this.config.webSocketServer) {
                 // Attach to existing WebSocket server
-                if (typeof transport.attachToWebSocketServer === 'function') {
+                if (typeof transport.attachToWebSocketServer === "function") {
                     await transport.attachToWebSocketServer(this.config.webSocketServer);
                 }
                 else {
-                    throw new Error('Transport adapter does not support attachToWebSocketServer');
+                    throw new Error("Transport adapter does not support attachToWebSocketServer");
                 }
             }
             else if (this.config.httpServer) {
                 // Attach to existing HTTP server
-                if (typeof transport.attach === 'function') {
-                    await transport.attach(this.config.httpServer, this.config.webSocketPath || '/ws');
+                if (typeof transport.attach === "function") {
+                    await transport.attach(this.config.httpServer, this.config.webSocketPath || "/ws");
                 }
                 else {
-                    throw new Error('Transport adapter does not support attach');
+                    throw new Error("Transport adapter does not support attach");
                 }
             }
             else {
-                throw new Error('Either httpServer or webSocketServer must be provided in integration mode');
+                throw new Error("Either httpServer or webSocketServer must be provided in integration mode");
             }
             this.running = true;
             this.initialized = true;
-            await this.emit('started', { port: 0 }); // Port 0 indicates integration mode
+            await this.emit("started", { port: 0 }); // Port 0 indicates integration mode
         }
         catch (error) {
-            await this.emit('error', { error: error, context: 'server_initialize' });
+            await this.emit("error", {
+                error: error,
+                context: "server_initialize",
+            });
             throw error;
         }
     }
@@ -172,13 +183,16 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         this.stopHeartbeatProcessor();
         // Disconnect all clients
         for (const [clientId] of Array.from(this.clients)) {
-            await this.disconnectClient(clientId, 'Server shutting down');
+            await this.disconnectClient(clientId, "Server shutting down");
         }
         try {
             await this.transport.disconnect();
         }
         catch (error) {
-            await this.emit('error', { error: error, context: 'server_stop' });
+            await this.emit("error", {
+                error: error,
+                context: "server_stop",
+            });
         }
         this.clients.clear();
         this.clientMessageHandlers.clear();
@@ -188,22 +202,22 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         if (this.presenceManager) {
             await this.presenceManager.clear();
         }
-        await this.emit('stopped', {});
+        await this.emit("stopped", {});
     }
     // Client Management
     async handleTransportMessage(message) {
         // Handle special transport messages
-        if (message.type === 'connection') {
+        if (message.type === "connection") {
             await this.handleConnectionMessage(message);
             return;
         }
-        if (message.type === 'client_authenticated') {
+        if (message.type === "client_authenticated") {
             await this.handleClientAuthenticatedMessage(message);
             return;
         }
-        if (message.type === 'disconnect') {
+        if (message.type === "disconnect") {
             const payload = message.payload;
-            await this.disconnectClient(payload.clientId, payload.reason || 'Client disconnected');
+            await this.disconnectClient(payload.clientId, payload.reason || "Client disconnected");
             return;
         }
         // Transport messages contain clientId in the payload for routing
@@ -213,12 +227,12 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
             id: message.id,
             type: type || message.type, // Use inner type if present, otherwise outer type
             payload: clientMessage,
-            timestamp: message.timestamp
+            timestamp: message.timestamp,
         };
         if (!clientId) {
-            await this.emit('error', {
-                error: new Error('Message missing clientId'),
-                context: 'transport_message'
+            await this.emit("error", {
+                error: new Error("Message missing clientId"),
+                context: "transport_message",
             });
             return;
         }
@@ -227,9 +241,9 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
             await handler(clientMsg);
         }
         else {
-            await this.emit('error', {
+            await this.emit("error", {
                 error: new Error(`No handler for client ${clientId}`),
-                context: 'transport_message'
+                context: "transport_message",
             });
         }
     }
@@ -239,55 +253,57 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         const roomIds = new Set();
         const client = {
             id: payload.clientId,
-            userId: payload.userId || '',
+            userId: payload.userId || "",
             roomIds,
             get roomId() {
-                return roomIds.size > 0 ? (roomIds.values().next().value || null) : null;
+                return roomIds.size > 0 ? roomIds.values().next().value || null : null;
             },
             authenticated: payload.authenticated,
-            connectedAt: Date.now()
+            connectedAt: Date.now(),
         };
         this.clients.set(payload.clientId, client);
         this.clientMessageHandlers.set(payload.clientId, this.createClientMessageHandler(payload.clientId));
-        await this.emit('client_connected', { client });
+        await this.emit("client_connected", { client });
         // Register with presence manager if authenticated
-        if (payload.authenticated && this.presenceManager?.isEnabled() && payload.userId) {
+        if (payload.authenticated &&
+            this.presenceManager?.isEnabled() &&
+            payload.userId) {
             try {
                 await this.presenceManager.connectDevice(payload.userId, payload.clientId, {
                     connectedAt: Date.now(),
                     lastActivity: Date.now(),
-                    metadata: payload.metadata
+                    metadata: payload.metadata,
                 });
-                await this.emit('presence_device_connected', {
+                await this.emit("presence_device_connected", {
                     userId: payload.userId,
                     deviceId: payload.clientId,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
                 // Broadcast presence update
                 const presenceConfig = this.presenceManager.getConfig();
                 if (presenceConfig.broadcastPresenceUpdates) {
                     await this.experimental.broadcastAuthenticated({
-                        type: 'presence:user_online',
+                        type: "presence:user_online",
                         payload: {
                             userId: payload.userId,
                             deviceId: payload.clientId,
-                            status: 'online'
-                        }
+                            status: "online",
+                        },
                     });
                 }
             }
             catch (error) {
-                await this.emit('error', {
+                await this.emit("error", {
                     error: error,
-                    context: 'presence_connect_device'
+                    context: "presence_connect_device",
                 });
             }
         }
         if (payload.authenticated) {
-            await this.emit('client_authenticated', {
+            await this.emit("client_authenticated", {
                 clientId: payload.clientId,
-                userId: payload.userId || '',
-                metadata: payload.metadata
+                userId: payload.userId || "",
+                metadata: payload.metadata,
             });
         }
     }
@@ -303,15 +319,15 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                 this.userClientMap.set(payload.userId, new Set());
             }
             this.userClientMap.get(payload.userId).add(payload.clientId);
-            await this.emit('client_authenticated', {
+            await this.emit("client_authenticated", {
                 clientId: payload.clientId,
                 userId: payload.userId,
-                metadata: payload.metadata
+                metadata: payload.metadata,
             });
         }
     }
     async handleTransportError(error) {
-        await this.emit('error', { error, context: 'transport' });
+        await this.emit("error", { error, context: "transport" });
     }
     async handleTransportClose(_code, _reason) {
         // Transport close means server is shutting down
@@ -323,18 +339,18 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         const roomIds = new Set();
         const client = {
             id: clientId,
-            userId: '',
+            userId: "",
             roomIds,
             get roomId() {
-                return roomIds.size > 0 ? (roomIds.values().next().value || null) : null;
+                return roomIds.size > 0 ? roomIds.values().next().value || null : null;
             },
             authenticated: false,
-            connectedAt: Date.now()
+            connectedAt: Date.now(),
         };
         this.clients.set(clientId, client);
         // Set up message handler for this client
         this.clientMessageHandlers.set(clientId, this.createClientMessageHandler(clientId));
-        await this.emit('client_connected', { client });
+        await this.emit("client_connected", { client });
     }
     async disconnectClient(clientId, reason) {
         const client = this.clients.get(clientId);
@@ -356,43 +372,44 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         if (this.presenceManager?.isEnabled() && client.userId) {
             try {
                 const presence = await this.presenceManager.disconnectDevice(client.userId, clientId);
-                await this.emit('presence_device_disconnected', {
+                await this.emit("presence_device_disconnected", {
                     userId: client.userId,
                     deviceId: clientId,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
                 // Broadcast presence update if user went offline or into grace period
                 const presenceConfig = this.presenceManager.getConfig();
-                if (presenceConfig.broadcastPresenceUpdates && (!presence || presence.status === 'offline')) {
+                if (presenceConfig.broadcastPresenceUpdates &&
+                    (!presence || presence.status === "offline")) {
                     await this.experimental.broadcastAuthenticated({
-                        type: 'presence:user_offline',
+                        type: "presence:user_offline",
                         payload: {
                             userId: client.userId,
                             deviceId: clientId,
-                            status: presence?.status || 'offline',
-                            gracePeriod: presenceConfig.gracePeriod
-                        }
+                            status: presence?.status || "offline",
+                            gracePeriod: presenceConfig.gracePeriod,
+                        },
                     });
                 }
             }
             catch (error) {
-                await this.emit('error', {
+                await this.emit("error", {
                     error: error,
-                    context: 'presence_disconnect_device'
+                    context: "presence_disconnect_device",
                 });
             }
         }
         // Leave all rooms the client is in
         for (const roomId of client.roomIds) {
             await this.roomManager.leaveRoom(roomId, client.userId);
-            await this.emit('client_left_room', { clientId, roomId });
+            await this.emit("client_left_room", { clientId, roomId });
         }
         // Release all locks held by this client
         await this.lockManager.releaseUserLocks(client.userId);
         // Clean up
         this.clients.delete(clientId);
         this.clientMessageHandlers.delete(clientId);
-        await this.emit('client_disconnected', { clientId, reason });
+        await this.emit("client_disconnected", { clientId, reason });
     }
     createClientMessageHandler(clientId) {
         return async (message) => {
@@ -402,57 +419,72 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                     return;
                 }
                 // Auto-update presence activity on ANY message
-                if (this.presenceManager?.isEnabled() && client.userId && client.authenticated) {
-                    await this.updatePresenceActivity(client.userId, clientId, 'message');
+                if (this.presenceManager?.isEnabled() &&
+                    client.userId &&
+                    client.authenticated) {
+                    await this.updatePresenceActivity(client.userId, clientId, "message");
                 }
                 switch (message.type) {
-                    case 'authenticate':
+                    case "authenticate":
                         await this.handleAuthenticate(clientId, message.payload);
                         break;
-                    case 'join_room':
+                    case "join_room":
                         await this.handleJoinRoom(clientId, message.payload);
                         break;
-                    case 'leave_room':
+                    case "leave_room":
                         await this.handleLeaveRoom(clientId, message.payload);
                         break;
-                    case 'broadcast_event':
+                    case "broadcast_event":
                         await this.handleBroadcastEvent(clientId, message.payload);
                         break;
-                    case 'request_lock':
+                    case "request_lock":
                         await this.handleLockRequest(clientId, message.payload);
                         break;
-                    case 'release_lock':
+                    case "release_lock":
                         await this.handleLockRelease(clientId, message.payload);
                         break;
-                    case 'ping':
-                        await this.sendToClient(clientId, { type: 'pong', timestamp: Date.now() });
+                    case "ping":
+                        await this.sendToClient(clientId, {
+                            type: "pong",
+                            timestamp: Date.now(),
+                        });
                         // Presence activity already updated automatically above
                         break;
-                    case 'heartbeat':
+                    case "heartbeat":
                         // Heartbeat messages are used to keep presence activity updated
                         // The activity is already tracked above (line ~570), so we just acknowledge
-                        await this.sendToClient(clientId, { type: 'heartbeat_ack', timestamp: Date.now() });
+                        await this.sendToClient(clientId, {
+                            type: "heartbeat_ack",
+                            timestamp: Date.now(),
+                        });
                         break;
                     default:
                         await this.sendToClient(clientId, {
-                            type: 'error',
-                            error: `Unknown message type: ${message.type}`
+                            type: "error",
+                            error: `Unknown message type: ${message.type}`,
                         });
                 }
             }
             catch (error) {
                 await this.sendToClient(clientId, {
-                    type: 'error',
-                    error: error.message
+                    type: "error",
+                    error: error.message,
+                });
+                await this.emit("error", {
+                    error: error,
+                    context: `client_${clientId}`,
                 });
-                await this.emit('error', { error: error, context: `client_${clientId}` });
             }
         };
     }
     // Message Handlers
     async handleAuthenticate(clientId, payload) {
         if (!this.auth) {
-            await this.sendToClient(clientId, { type: 'auth_result', success: false, error: 'Authentication not configured' });
+            await this.sendToClient(clientId, {
+                type: "auth_result",
+                success: false,
+                error: "Authentication not configured",
+            });
             return;
         }
         try {
@@ -467,16 +499,24 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                     this.userClientMap.set(tokenPayload.userId, new Set());
                 }
                 this.userClientMap.get(tokenPayload.userId).add(clientId);
-                await this.emit('client_authenticated', {
+                await this.emit("client_authenticated", {
                     clientId,
                     userId: tokenPayload.userId,
-                    metadata: tokenPayload.metadata
+                    metadata: tokenPayload.metadata,
                 });
             }
-            await this.sendToClient(clientId, { type: 'auth_result', success: true, userId: tokenPayload.userId });
+            await this.sendToClient(clientId, {
+                type: "auth_result",
+                success: true,
+                userId: tokenPayload.userId,
+            });
         }
         catch (error) {
-            await this.sendToClient(clientId, { type: 'auth_result', success: false, error: error.message });
+            await this.sendToClient(clientId, {
+                type: "auth_result",
+                success: false,
+                error: error.message,
+            });
         }
     }
     async handleJoinRoom(clientId, payload) {
@@ -489,62 +529,77 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
             await this.handleAuthenticate(clientId, { token: payload.token });
         }
         if (!client.authenticated) {
-            await this.sendToClient(clientId, { type: 'error', error: 'Authentication required to join room' });
+            await this.sendToClient(clientId, {
+                type: "error",
+                error: "Authentication required to join room",
+            });
             return;
         }
         try {
             // Check if already in the room
             if (client.roomIds.has(payload.roomId)) {
-                await this.sendToClient(clientId, { type: 'error', error: 'Already in this room' });
+                await this.sendToClient(clientId, {
+                    type: "error",
+                    error: "Already in this room",
+                });
                 return;
             }
             // Get or create room
             let roomState = await this.roomManager.getRoomState(payload.roomId);
             if (!roomState) {
-                const roomConfig = { ...this.config.defaultRoomConfig, id: payload.roomId };
+                const roomConfig = {
+                    ...this.config.defaultRoomConfig,
+                    id: payload.roomId,
+                };
                 const room = await this.roomManager.createRoom(payload.roomId, roomConfig);
                 roomState = await this.roomManager.getRoomState(payload.roomId);
-                await this.emit('room_created', { room });
+                await this.emit("room_created", { room });
             }
             if (!roomState) {
-                throw new Error('Failed to create or get room state');
+                throw new Error("Failed to create or get room state");
             }
             // Join room
             const user = {
                 id: client.userId,
                 username: client.userId, // TODO: Get from auth token
-                status: 'online',
+                status: "online",
                 joinedAt: Date.now(),
                 lastActivity: Date.now(),
-                permissions: roomState.room.permissions || ['read', 'write']
+                permissions: roomState.room.permissions || ["read", "write"],
             };
             await this.roomManager.joinRoom(payload.roomId, user);
             client.roomIds.add(payload.roomId);
-            await this.emit('client_joined_room', { clientId, roomId: payload.roomId });
+            await this.emit("client_joined_room", {
+                clientId,
+                roomId: payload.roomId,
+            });
             // Get updated room state after joining (so it includes the current user)
             const updatedRoomState = await this.roomManager.getRoomState(payload.roomId);
             if (!updatedRoomState) {
-                throw new Error('Failed to get updated room state after joining');
+                throw new Error("Failed to get updated room state after joining");
             }
             // Convert Maps to plain objects for JSON serialization
             const serializableState = (0, room_js_1.serializeRoomState)(updatedRoomState);
             // Send room state to client
             await this.sendToClient(clientId, {
-                type: 'room_joined',
+                type: "room_joined",
                 roomId: payload.roomId,
-                state: serializableState
+                state: serializableState,
             });
             // Send event history
             const history = await this.roomManager.getEventHistory(payload.roomId, 50);
             if (history.length > 0) {
                 await this.sendToClient(clientId, {
-                    type: 'event_history',
-                    events: history
+                    type: "event_history",
+                    events: history,
                 });
             }
         }
         catch (error) {
-            await this.sendToClient(clientId, { type: 'error', error: error.message });
+            await this.sendToClient(clientId, {
+                type: "error",
+                error: error.message,
+            });
         }
     }
     async handleLeaveRoom(clientId, payload) {
@@ -566,14 +621,17 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
             }
             await this.roomManager.leaveRoom(roomId, client.userId);
             client.roomIds.delete(roomId);
-            await this.emit('client_left_room', { clientId, roomId });
-            await this.sendToClient(clientId, { type: 'room_left', roomId });
+            await this.emit("client_left_room", { clientId, roomId });
+            await this.sendToClient(clientId, { type: "room_left", roomId });
         }
     }
     async handleBroadcastEvent(clientId, payload) {
         const client = this.clients.get(clientId);
         if (!client || !client.roomIds.has(payload.roomId)) {
-            await this.sendToClient(clientId, { type: 'error', error: 'Not in specified room' });
+            await this.sendToClient(clientId, {
+                type: "error",
+                error: "Not in specified room",
+            });
             return;
         }
         // Add metadata to event
@@ -583,42 +641,53 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                 ...payload.event.metadata,
                 userId: client.userId,
                 timestamp: Date.now(),
-                roomId: payload.roomId
-            }
+                roomId: payload.roomId,
+            },
         };
         // Add to history
         await this.roomManager.addEventToHistory(payload.roomId, enrichedEvent);
         // Broadcast to room
         await this.roomManager.broadcastToRoom(payload.roomId, enrichedEvent, client.userId);
-        await this.emit('event_broadcast', {
+        await this.emit("event_broadcast", {
             roomId: payload.roomId,
             event: enrichedEvent,
-            fromClientId: clientId
+            fromClientId: clientId,
         });
     }
     async handleLockRequest(clientId, payload) {
         const client = this.clients.get(clientId);
         if (!client || !client.roomIds.has(payload.roomId)) {
-            await this.sendToClient(clientId, { type: 'error', error: 'Not in specified room' });
+            await this.sendToClient(clientId, {
+                type: "error",
+                error: "Not in specified room",
+            });
             return;
         }
         try {
             const lock = await this.lockManager.acquireLock(client.userId, client.userId, payload.request);
-            await this.emit('lock_acquired', { lock, clientId });
-            await this.sendToClient(clientId, { type: 'lock_acquired', lock });
+            await this.emit("lock_acquired", { lock, clientId });
+            await this.sendToClient(clientId, { type: "lock_acquired", lock });
             // Broadcast lock status to room
             await this.roomManager.broadcastToRoom(payload.roomId, {
                 id: this.generateId(),
-                type: 'lock_status',
+                type: "lock_status",
                 timestamp: Date.now(),
                 userId: client.userId,
                 roomId: payload.roomId,
-                data: { lock, action: 'acquired' },
-                metadata: { userId: client.userId, timestamp: Date.now(), roomId: payload.roomId }
+                data: { lock, action: "acquired" },
+                metadata: {
+                    userId: client.userId,
+                    timestamp: Date.now(),
+                    roomId: payload.roomId,
+                },
             });
         }
         catch (error) {
-            await this.sendToClient(clientId, { type: 'lock_denied', request: payload.request, reason: error.message });
+            await this.sendToClient(clientId, {
+                type: "lock_denied",
+                request: payload.request,
+                reason: error.message,
+            });
         }
     }
     async handleLockRelease(clientId, payload) {
@@ -628,32 +697,38 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
         }
         try {
             await this.lockManager.releaseLock(payload.lockId);
-            await this.emit('lock_released', { lockId: payload.lockId, clientId });
-            await this.sendToClient(clientId, { type: 'lock_released', lockId: payload.lockId });
+            await this.emit("lock_released", { lockId: payload.lockId, clientId });
+            await this.sendToClient(clientId, {
+                type: "lock_released",
+                lockId: payload.lockId,
+            });
             // Broadcast lock status to all rooms the client is in
             for (const roomId of client.roomIds) {
                 await this.roomManager.broadcastToRoom(roomId, {
                     id: this.generateId(),
-                    type: 'lock_status',
+                    type: "lock_status",
                     timestamp: Date.now(),
                     userId: client.userId,
                     roomId,
-                    data: { lockId: payload.lockId, action: 'released' },
-                    metadata: { userId: client.userId, timestamp: Date.now(), roomId }
+                    data: { lockId: payload.lockId, action: "released" },
+                    metadata: { userId: client.userId, timestamp: Date.now(), roomId },
                 });
             }
         }
         catch (error) {
-            await this.sendToClient(clientId, { type: 'error', error: error.message });
+            await this.sendToClient(clientId, {
+                type: "error",
+                error: error.message,
+            });
         }
     }
     // Utility Methods
     async sendToClient(clientId, message) {
         const transportMessage = {
             id: this.generateId(),
-            type: 'server_message',
+            type: "server_message",
             payload: { clientId, ...message },
-            timestamp: Date.now()
+            timestamp: Date.now(),
         };
         await this.transport.send(transportMessage);
     }
@@ -663,12 +738,12 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
     // Public API for external management
     async createRoom(roomId, config) {
         const room = await this.roomManager.createRoom(roomId, config);
-        await this.emit('room_created', { room });
+        await this.emit("room_created", { room });
         return room;
     }
     async deleteRoom(roomId) {
         await this.roomManager.deleteRoom(roomId);
-        await this.emit('room_deleted', { roomId });
+        await this.emit("room_deleted", { roomId });
     }
     getConnectedClients() {
         return Array.from(this.clients.values());
@@ -701,19 +776,19 @@ class BaseServer extends EventEmitter_js_1.TypedEventEmitter {
                 userId,
                 deviceId,
                 timestamp: Date.now(),
-                activityType
+                activityType,
             });
-            await this.emit('presence_activity', {
+            await this.emit("presence_activity", {
                 userId,
                 deviceId,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
         }
         catch (error) {
             // Don't throw, just log the error
-            await this.emit('error', {
+            await this.emit("error", {
                 error: error,
-                context: 'presence_update_activity'
+                context: "presence_update_activity",
             });
         }
     }