@principal-ai/control-tower-core 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -0,0 +1,1402 @@
+// src/abstractions/EventEmitter.ts
+class TypedEventEmitter {
+  listeners = new Map;
+  onceListeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, new Set);
+    }
+    this.onceListeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    this.onceListeners.get(event)?.delete(listener);
+  }
+  async emit(event, data) {
+    const listeners = this.listeners.get(event);
+    const onceListeners = this.onceListeners.get(event);
+    if (onceListeners) {
+      const listenersToCall = Array.from(onceListeners);
+      this.onceListeners.delete(event);
+      for (const listener of listenersToCall) {
+        await listener(data);
+      }
+    }
+    if (listeners) {
+      for (const listener of Array.from(listeners)) {
+        await listener(data);
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+      this.onceListeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.onceListeners.clear();
+    }
+  }
+  listenerCount(event) {
+    const regular = this.listeners.get(event)?.size ?? 0;
+    const once = this.onceListeners.get(event)?.size ?? 0;
+    return regular + once;
+  }
+}
+// src/abstractions/RoomManager.ts
+class RoomManager {
+  rooms = new Map;
+}
+// src/abstractions/LockManager.ts
+class LockManager {
+  lockState = {
+    locks: new Map,
+    queue: new Map,
+    userLocks: new Map
+  };
+}
+// src/abstractions/DefaultRoomManager.ts
+class DefaultRoomManager extends RoomManager {
+  async createRoom(id, config) {
+    const room = {
+      id,
+      name: config.name || id,
+      createdAt: Date.now(),
+      maxUsers: config.maxUsers,
+      maxHistory: config.maxHistory,
+      permissions: config.permissions,
+      metadata: config.metadata || {}
+    };
+    const roomState = {
+      room,
+      users: new Map,
+      eventHistory: [],
+      locks: new Map
+    };
+    this.rooms.set(id, roomState);
+    return room;
+  }
+  async deleteRoom(id) {
+    this.rooms.delete(id);
+  }
+  async joinRoom(roomId, user) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    if (roomState.room.maxUsers && roomState.users.size >= roomState.room.maxUsers) {
+      throw new Error(`Room ${roomId} is full`);
+    }
+    roomState.users.set(user.id, user);
+  }
+  async leaveRoom(roomId, userId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return;
+    }
+    roomState.users.delete(userId);
+  }
+  async broadcastToRoom(roomId, event, _excludeUserId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    await this.addEventToHistory(roomId, event);
+  }
+  async getRoomState(roomId) {
+    return this.rooms.get(roomId) || null;
+  }
+  async getUsersInRoom(roomId) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
+    }
+    return Array.from(roomState.users.values());
+  }
+  async addEventToHistory(roomId, event) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    roomState.eventHistory.push(event);
+    if (roomState.room.maxHistory && roomState.eventHistory.length > roomState.room.maxHistory) {
+      roomState.eventHistory = roomState.eventHistory.slice(-roomState.room.maxHistory);
+    }
+  }
+  async getEventHistory(roomId, limit) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      return [];
+    }
+    const history = roomState.eventHistory;
+    return limit ? history.slice(-limit) : history;
+  }
+  async updateUserStatus(roomId, userId, status) {
+    const roomState = this.rooms.get(roomId);
+    if (!roomState) {
+      throw new Error(`Room ${roomId} not found`);
+    }
+    const user = roomState.users.get(userId);
+    if (user) {
+      user.status = status;
+      user.lastActivity = Date.now();
+    }
+  }
+}
+// src/abstractions/DefaultLockManager.ts
+class DefaultLockManager extends LockManager {
+  async acquireLock(userId, username, request) {
+    const { path, type = "file", priority = "normal", ttl, branch, metadata } = request;
+    const userLocks = this.lockState.userLocks.get(userId) || new Set;
+    if (userLocks.has(path)) {
+      throw new Error(`User ${username} already has a lock on ${path}`);
+    }
+    const existingLock = await this.getLock(path);
+    if (existingLock) {
+      await this.addToQueue(userId, username, request);
+      throw new Error(`Path ${path} is already locked by ${existingLock.username}, added to queue`);
+    }
+    const lockId = this.generateId();
+    const lock = {
+      id: lockId,
+      type,
+      path,
+      userId,
+      username,
+      acquiredAt: Date.now(),
+      expiresAt: ttl ? Date.now() + ttl : undefined,
+      priority,
+      branch,
+      metadata
+    };
+    this.lockState.locks.set(lockId, lock);
+    this.lockState.userLocks.set(userId, userLocks.add(path));
+    return lock;
+  }
+  async releaseLock(lockId) {
+    const lock = this.lockState.locks.get(lockId);
+    if (!lock) {
+      throw new Error(`Lock ${lockId} not found`);
+    }
+    const userLocks = this.lockState.userLocks.get(lock.userId);
+    if (userLocks) {
+      userLocks.delete(lock.path);
+      if (userLocks.size === 0) {
+        this.lockState.userLocks.delete(lock.userId);
+      }
+    }
+    this.lockState.locks.delete(lockId);
+    await this.processQueue(lock.path);
+  }
+  async releaseUserLocks(userId) {
+    const userLocks = this.lockState.userLocks.get(userId);
+    if (!userLocks) {
+      return;
+    }
+    const lockIds = Array.from(this.lockState.locks.entries()).filter(([, lock]) => lock.userId === userId).map(([lockId]) => lockId);
+    for (const lockId of lockIds) {
+      await this.releaseLock(lockId);
+    }
+  }
+  async getLock(path) {
+    for (const lock of this.lockState.locks.values()) {
+      if (lock.path === path) {
+        return lock;
+      }
+    }
+    return null;
+  }
+  async getUserLocks(userId) {
+    return Array.from(this.lockState.locks.values()).filter((lock) => lock.userId === userId);
+  }
+  async getAllLocks() {
+    return Array.from(this.lockState.locks.values());
+  }
+  async isLocked(path) {
+    return await this.getLock(path) !== null;
+  }
+  async getQueueLength(path) {
+    const queue = this.lockState.queue.get(path);
+    return queue ? queue.length : 0;
+  }
+  async extendLock(lockId, ttl) {
+    const lock = this.lockState.locks.get(lockId);
+    if (!lock) {
+      throw new Error(`Lock ${lockId} not found`);
+    }
+    lock.expiresAt = Date.now() + ttl;
+    return lock;
+  }
+  async addToQueue(userId, username, request) {
+    const { path } = request;
+    const queue = this.lockState.queue.get(path) || [];
+    const queueItem = {
+      ...request,
+      userId,
+      username,
+      requestedAt: Date.now(),
+      resolve: () => {},
+      reject: () => {}
+    };
+    queue.push(queueItem);
+    this.lockState.queue.set(path, queue);
+  }
+  async removeFromQueue(path, userId) {
+    const queue = this.lockState.queue.get(path);
+    if (!queue) {
+      return;
+    }
+    const index = queue.findIndex((item) => item.userId === userId);
+    if (index !== -1) {
+      queue.splice(index, 1);
+      if (queue.length === 0) {
+        this.lockState.queue.delete(path);
+      }
+    }
+  }
+  generateId() {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+  }
+  async processQueue(path) {
+    const queue = this.lockState.queue.get(path);
+    if (!queue || queue.length === 0) {
+      return;
+    }
+    const item = queue.shift();
+    if (queue.length === 0) {
+      this.lockState.queue.delete(path);
+    }
+    try {
+      const lock = await this.acquireLock(item.userId, item.username, {
+        path: item.path,
+        type: item.type,
+        priority: item.priority,
+        ttl: item.ttl,
+        branch: item.branch,
+        metadata: item.metadata
+      });
+      item.resolve(lock);
+    } catch (error) {
+      item.reject(error);
+    }
+  }
+}
+// src/adapters/mock/MockTransportAdapter.ts
+class MockTransportAdapter {
+  state = "disconnected";
+  messageHandlers = new Set;
+  errorHandlers = new Set;
+  closeHandlers = new Set;
+  messageQueue = [];
+  simulateLatency = 0;
+  shouldFailConnection = false;
+  connectedUrl = null;
+  constructor(options) {
+    this.simulateLatency = options?.simulateLatency ?? 0;
+    this.shouldFailConnection = options?.shouldFailConnection ?? false;
+  }
+  async connect(url, _options) {
+    if (this.shouldFailConnection) {
+      this.state = "disconnected";
+      const error = new Error("Mock connection failed");
+      this.errorHandlers.forEach((handler) => handler(error));
+      throw error;
+    }
+    this.state = "connecting";
+    this.connectedUrl = url;
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+    this.state = "connected";
+  }
+  async disconnect() {
+    if (this.state === "disconnected")
+      return;
+    this.state = "disconnecting";
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency / 2));
+    }
+    this.state = "disconnected";
+    this.connectedUrl = null;
+    this.closeHandlers.forEach((handler) => handler(1000, "Normal closure"));
+    this.messageQueue = [];
+  }
+  async send(message) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+    this.messageQueue.push(message);
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+  }
+  onClose(handler) {
+    this.closeHandlers.add(handler);
+  }
+  getState() {
+    return this.state;
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  simulateMessage(message) {
+    if (this.state !== "connected") {
+      throw new Error("Cannot simulate message when not connected");
+    }
+    this.messageHandlers.forEach((handler) => handler(message));
+  }
+  simulateError(error) {
+    this.errorHandlers.forEach((handler) => handler(error));
+  }
+  simulateClose(code, reason) {
+    this.state = "disconnected";
+    this.closeHandlers.forEach((handler) => handler(code, reason));
+  }
+  getMessageQueue() {
+    return [...this.messageQueue];
+  }
+  clearMessageQueue() {
+    this.messageQueue = [];
+  }
+  getConnectedUrl() {
+    return this.connectedUrl;
+  }
+}
+// src/adapters/mock/MockStorageAdapter.ts
+class MockStorageAdapter {
+  storage = new Map;
+  simulateLatency = 0;
+  shouldFailOperations = false;
+  constructor(options) {
+    this.simulateLatency = options?.simulateLatency ?? 0;
+    this.shouldFailOperations = options?.shouldFailOperations ?? false;
+  }
+  async get(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = this.storage.get(key);
+    if (!item)
+      return null;
+    if (item.expiresAt && item.expiresAt < Date.now()) {
+      this.storage.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+  async set(key, value, ttl) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = {
+      value,
+      expiresAt: ttl ? Date.now() + ttl : undefined
+    };
+    this.storage.set(key, item);
+  }
+  async delete(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    this.storage.delete(key);
+  }
+  async exists(key) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const item = this.storage.get(key);
+    if (!item)
+      return false;
+    if (item.expiresAt && item.expiresAt < Date.now()) {
+      this.storage.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async scan(pattern) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\[!/g, "[^").replace(/\[/g, "[").replace(/\]/g, "]");
+    const regex = new RegExp(`^${regexPattern}$`);
+    const keys = [];
+    for (const [key, item] of this.storage.entries()) {
+      if (item.expiresAt && item.expiresAt < Date.now()) {
+        this.storage.delete(key);
+        continue;
+      }
+      if (regex.test(key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  async clear() {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    this.storage.clear();
+  }
+  async transaction(operations) {
+    await this.simulateDelay();
+    if (this.shouldFailOperations) {
+      throw new Error("Mock storage operation failed");
+    }
+    const results = [];
+    const rollback = [];
+    try {
+      for (const op of operations) {
+        switch (op.type) {
+          case "get": {
+            const value = await this.get(op.key);
+            results.push(value);
+            break;
+          }
+          case "set": {
+            const oldValue = await this.get(op.key);
+            await this.set(op.key, op.value, op.ttl);
+            rollback.push(() => {
+              if (oldValue !== null) {
+                this.storage.set(op.key, { value: oldValue });
+              } else {
+                this.storage.delete(op.key);
+              }
+            });
+            results.push(true);
+            break;
+          }
+          case "delete": {
+            const oldValue = await this.get(op.key);
+            await this.delete(op.key);
+            rollback.push(() => {
+              if (oldValue !== null) {
+                this.storage.set(op.key, { value: oldValue });
+              }
+            });
+            results.push(true);
+            break;
+          }
+          case "exists": {
+            const exists = await this.exists(op.key);
+            results.push(exists);
+            break;
+          }
+        }
+      }
+      return results;
+    } catch (error) {
+      for (const rollbackFn of rollback.reverse()) {
+        rollbackFn();
+      }
+      throw error;
+    }
+  }
+  async simulateDelay() {
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+  }
+  getSize() {
+    return this.storage.size;
+  }
+  getRawStorage() {
+    return new Map(this.storage);
+  }
+  setFailOperations(fail) {
+    this.shouldFailOperations = fail;
+  }
+}
+// src/adapters/mock/MockAuthAdapter.ts
+class MockAuthAdapter {
+  tokens = new Map;
+  revokedTokens = new Set;
+  users = new Map;
+  simulateLatency = 0;
+  shouldFailAuth = false;
+  tokenCounter = 0;
+  constructor(options) {
+    this.simulateLatency = options?.simulateLatency ?? 0;
+    this.shouldFailAuth = options?.shouldFailAuth ?? false;
+    this.addUser("testuser", "password123", {
+      userId: "user-1",
+      email: "test@example.com",
+      username: "testuser",
+      permissions: ["read", "write"]
+    });
+    this.addUser("admin", "admin123", {
+      userId: "user-admin",
+      email: "admin@example.com",
+      username: "admin",
+      permissions: ["read", "write", "admin"]
+    });
+  }
+  async validateToken(token) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock auth validation failed");
+    }
+    if (this.revokedTokens.has(token)) {
+      throw new Error("Token has been revoked");
+    }
+    const payload = this.tokens.get(token);
+    if (!payload) {
+      throw new Error("Invalid token");
+    }
+    if (payload.expiresAt && payload.expiresAt < Date.now()) {
+      this.tokens.delete(token);
+      throw new Error("Token expired");
+    }
+    return payload;
+  }
+  async generateToken(payload) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token generation failed");
+    }
+    const token = `mock-token-${++this.tokenCounter}`;
+    const expiresAt = payload.expiresAt ?? Date.now() + 3600000;
+    this.tokens.set(token, { ...payload, expiresAt });
+    return token;
+  }
+  async refreshToken(token) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token refresh failed");
+    }
+    const payload = await this.validateToken(token);
+    await this.revokeToken(token);
+    const newPayload = {
+      ...payload,
+      expiresAt: Date.now() + 3600000
+    };
+    return this.generateToken(newPayload);
+  }
+  async revokeToken(token) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock token revocation failed");
+    }
+    this.tokens.delete(token);
+    this.revokedTokens.add(token);
+  }
+  async authenticate(credentials) {
+    await this.simulateDelay();
+    if (this.shouldFailAuth) {
+      throw new Error("Mock authentication failed");
+    }
+    switch (credentials.type) {
+      case "password": {
+        if (!credentials.username || !credentials.password) {
+          throw new Error("Username and password required");
+        }
+        const user = this.users.get(credentials.username);
+        if (!user || user.password !== credentials.password) {
+          throw new Error("Invalid credentials");
+        }
+        const token = await this.generateToken(user.payload);
+        const refreshToken = `refresh-${token}`;
+        this.tokens.set(refreshToken, user.payload);
+        return {
+          token,
+          refreshToken,
+          user: user.payload,
+          expiresIn: 3600
+        };
+      }
+      case "token": {
+        if (!credentials.token) {
+          throw new Error("Token required");
+        }
+        const payload = await this.validateToken(credentials.token);
+        return {
+          token: credentials.token,
+          user: payload,
+          expiresIn: 3600
+        };
+      }
+      case "oauth": {
+        if (!credentials.code) {
+          throw new Error("OAuth code required");
+        }
+        const payload = {
+          userId: `oauth-user-${Date.now()}`,
+          email: "oauth@example.com",
+          username: "oauthuser",
+          permissions: ["read", "write"]
+        };
+        const token = await this.generateToken(payload);
+        return {
+          token,
+          user: payload,
+          expiresIn: 3600
+        };
+      }
+      default:
+        throw new Error("Unsupported credential type");
+    }
+  }
+  async simulateDelay() {
+    if (this.simulateLatency > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.simulateLatency));
+    }
+  }
+  addUser(username, password, payload) {
+    this.users.set(username, { password, payload });
+  }
+  removeUser(username) {
+    this.users.delete(username);
+  }
+  getTokenCount() {
+    return this.tokens.size;
+  }
+  getRevokedTokenCount() {
+    return this.revokedTokens.size;
+  }
+  clearTokens() {
+    this.tokens.clear();
+    this.revokedTokens.clear();
+  }
+  setFailAuth(fail) {
+    this.shouldFailAuth = fail;
+  }
+}
+// src/client/BaseClient.ts
+class BaseClient extends TypedEventEmitter {
+  transport;
+  auth;
+  storage;
+  config;
+  connectionState = "disconnected";
+  currentRoomId = null;
+  currentRoomState = null;
+  authToken = null;
+  userId = null;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  lastConnectionUrl = null;
+  lastCredentials = null;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.transport = config.transport;
+    this.auth = config.auth;
+    this.storage = config.storage;
+    this.transport.onMessage(this.handleMessage.bind(this));
+    this.transport.onError(this.handleError.bind(this));
+    this.transport.onClose(this.handleClose.bind(this));
+  }
+  async connect(url, credentials) {
+    if (this.connectionState !== "disconnected") {
+      throw new Error("Client is already connected or connecting");
+    }
+    this.connectionState = "connecting";
+    this.lastConnectionUrl = url;
+    this.lastCredentials = credentials || null;
+    try {
+      if (credentials && this.auth) {
+        const authResult = await this.auth.authenticate(credentials);
+        this.authToken = authResult.token;
+        this.userId = authResult.user.userId;
+      }
+      const options = {
+        url,
+        reconnect: false,
+        ...this.config.reconnection
+      };
+      await this.transport.connect(url, options);
+      this.connectionState = "connected";
+      await this.emit("connected", { url });
+    } catch (error) {
+      this.connectionState = "disconnected";
+      await this.emit("error", { error });
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.connectionState === "disconnected") {
+      return;
+    }
+    this.connectionState = "disconnecting";
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.currentRoomId) {
+      await this.leaveRoom();
+    }
+    try {
+      await this.transport.disconnect();
+    } finally {
+      this.connectionState = "disconnected";
+      this.currentRoomId = null;
+      this.currentRoomState = null;
+      this.authToken = null;
+      this.userId = null;
+      this.reconnectAttempts = 0;
+      await this.emit("disconnected", { code: 1000, reason: "Client disconnected" });
+    }
+  }
+  async reconnect() {
+    if (!this.lastConnectionUrl) {
+      throw new Error("No previous connection to reconnect to");
+    }
+    if (this.connectionState !== "disconnected") {
+      await this.disconnect();
+    }
+    await this.connect(this.lastConnectionUrl, this.lastCredentials || undefined);
+  }
+  async joinRoom(roomId) {
+    if (this.connectionState !== "connected") {
+      throw new Error("Client must be connected to join a room");
+    }
+    if (this.currentRoomId) {
+      await this.leaveRoom();
+    }
+    const message = {
+      id: this.generateId(),
+      type: "join_room",
+      payload: { roomId, token: this.authToken },
+      timestamp: Date.now()
+    };
+    await this.transport.send(message);
+  }
+  async leaveRoom() {
+    if (!this.currentRoomId) {
+      return;
+    }
+    const message = {
+      id: this.generateId(),
+      type: "leave_room",
+      payload: { roomId: this.currentRoomId },
+      timestamp: Date.now()
+    };
+    await this.transport.send(message);
+    this.currentRoomId = null;
+    this.currentRoomState = null;
+  }
+  async broadcast(event) {
+    if (this.connectionState !== "connected" || !this.currentRoomId) {
+      throw new Error("Client must be connected and in a room to broadcast events");
+    }
+    const message = {
+      id: this.generateId(),
+      type: "broadcast_event",
+      payload: { event, roomId: this.currentRoomId },
+      timestamp: Date.now()
+    };
+    await this.transport.send(message);
+  }
+  async requestLock(request) {
+    if (this.connectionState !== "connected" || !this.currentRoomId) {
+      throw new Error("Client must be connected and in a room to request locks");
+    }
+    const message = {
+      id: this.generateId(),
+      type: "request_lock",
+      payload: { request, roomId: this.currentRoomId },
+      timestamp: Date.now()
+    };
+    await this.transport.send(message);
+  }
+  async releaseLock(lockId) {
+    if (this.connectionState !== "connected" || !this.currentRoomId) {
+      throw new Error("Client must be connected and in a room to release locks");
+    }
+    const message = {
+      id: this.generateId(),
+      type: "release_lock",
+      payload: { lockId, roomId: this.currentRoomId },
+      timestamp: Date.now()
+    };
+    await this.transport.send(message);
+  }
+  getConnectionState() {
+    return this.connectionState;
+  }
+  getRoomState() {
+    return this.currentRoomState;
+  }
+  getPresence() {
+    return this.currentRoomState ? Array.from(this.currentRoomState.users.values()) : [];
+  }
+  getCurrentRoomId() {
+    return this.currentRoomId;
+  }
+  getUserId() {
+    return this.userId;
+  }
+  async handleMessage(message) {
+    try {
+      switch (message.type) {
+        case "room_joined":
+          await this.handleRoomJoined(message.payload);
+          break;
+        case "room_left":
+          await this.handleRoomLeft(message.payload);
+          break;
+        case "event_broadcast":
+          await this.handleEventBroadcast(message.payload);
+          break;
+        case "lock_acquired":
+          await this.handleLockAcquired(message.payload);
+          break;
+        case "lock_released":
+          await this.handleLockReleased(message.payload);
+          break;
+        case "lock_denied":
+          await this.handleLockDenied(message.payload);
+          break;
+        case "presence_updated":
+          await this.handlePresenceUpdated(message.payload);
+          break;
+        case "error":
+          await this.handleServerError(message.payload);
+          break;
+      }
+    } catch (error) {
+      await this.emit("error", { error });
+    }
+  }
+  async handleError(error) {
+    await this.emit("error", { error });
+  }
+  async handleClose(code, reason) {
+    const wasConnected = this.connectionState === "connected";
+    this.connectionState = "disconnected";
+    if (wasConnected) {
+      await this.emit("disconnected", { code, reason });
+      if (this.config.reconnection?.enabled && this.lastConnectionUrl) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+  async handleRoomJoined(payload) {
+    this.currentRoomId = payload.roomId;
+    this.currentRoomState = payload.state;
+    await this.emit("room_joined", payload);
+  }
+  async handleRoomLeft(payload) {
+    if (this.currentRoomId === payload.roomId) {
+      this.currentRoomId = null;
+      this.currentRoomState = null;
+    }
+    await this.emit("room_left", payload);
+  }
+  async handleEventBroadcast(payload) {
+    await this.emit("event_received", payload);
+  }
+  async handleLockAcquired(payload) {
+    await this.emit("lock_acquired", payload);
+  }
+  async handleLockReleased(payload) {
+    await this.emit("lock_released", payload);
+  }
+  async handleLockDenied(payload) {
+    await this.emit("lock_denied", payload);
+  }
+  async handlePresenceUpdated(payload) {
+    if (this.currentRoomState) {
+      this.currentRoomState.users = new Map(payload.users.map((user) => [user.id, user]));
+    }
+    await this.emit("presence_updated", payload);
+  }
+  async handleServerError(payload) {
+    const error = new Error(payload.error);
+    await this.emit("error", { error });
+  }
+  async scheduleReconnect() {
+    if (!this.config.reconnection || this.reconnectAttempts >= this.config.reconnection.maxAttempts) {
+      return;
+    }
+    const delay = Math.min(this.config.reconnection.initialDelay * Math.pow(this.config.reconnection.backoffFactor, this.reconnectAttempts), this.config.reconnection.maxDelay);
+    this.reconnectAttempts++;
+    await this.emit("reconnecting", { attempt: this.reconnectAttempts, delay });
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.reconnect();
+        this.reconnectAttempts = 0;
+        await this.emit("reconnected", { url: this.lastConnectionUrl });
+      } catch {
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  generateId() {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+  }
+}
+// src/client/ClientBuilder.ts
+class ClientBuilder {
+  transport;
+  auth;
+  storage;
+  reconnection;
+  withTransport(transport) {
+    this.transport = transport;
+    return this;
+  }
+  withAuth(auth) {
+    this.auth = auth;
+    return this;
+  }
+  withStorage(storage) {
+    this.storage = storage;
+    return this;
+  }
+  withReconnection(config) {
+    this.reconnection = config;
+    return this;
+  }
+  build() {
+    if (!this.transport) {
+      throw new Error("Transport adapter is required");
+    }
+    const config = {
+      transport: this.transport,
+      auth: this.auth,
+      storage: this.storage,
+      reconnection: this.reconnection || {
+        enabled: true,
+        maxAttempts: 5,
+        initialDelay: 1000,
+        maxDelay: 30000,
+        backoffFactor: 2
+      }
+    };
+    return new BaseClient(config);
+  }
+}
+// src/server/BaseServer.ts
+class BaseServer extends TypedEventEmitter {
+  transport;
+  auth;
+  storage;
+  roomManager;
+  lockManager;
+  config;
+  clients = new Map;
+  clientMessageHandlers = new Map;
+  running = false;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.transport = config.transport;
+    this.auth = config.auth;
+    this.storage = config.storage;
+    this.roomManager = config.roomManager;
+    this.lockManager = config.lockManager;
+    this.transport.onMessage(this.handleTransportMessage.bind(this));
+    this.transport.onError(this.handleTransportError.bind(this));
+    this.transport.onClose(this.handleTransportClose.bind(this));
+  }
+  async start(port) {
+    if (this.running) {
+      throw new Error("Server is already running");
+    }
+    try {
+      await this.transport.connect(`ws://localhost:${port}`, { url: `ws://localhost:${port}` });
+      this.running = true;
+      await this.emit("started", { port });
+    } catch (error) {
+      await this.emit("error", { error, context: "server_start" });
+      throw error;
+    }
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    for (const [clientId] of Array.from(this.clients)) {
+      await this.disconnectClient(clientId, "Server shutting down");
+    }
+    try {
+      await this.transport.disconnect();
+    } catch (error) {
+      await this.emit("error", { error, context: "server_stop" });
+    }
+    this.clients.clear();
+    this.clientMessageHandlers.clear();
+    await this.emit("stopped", {});
+  }
+  async handleTransportMessage(message) {
+    const payload = message.payload;
+    const { clientId, ...clientMessage } = payload;
+    const clientMsg = {
+      id: message.id,
+      type: message.type,
+      payload: clientMessage,
+      timestamp: message.timestamp
+    };
+    if (!clientId) {
+      await this.emit("error", {
+        error: new Error("Message missing clientId"),
+        context: "transport_message"
+      });
+      return;
+    }
+    const handler = this.clientMessageHandlers.get(clientId);
+    if (handler) {
+      await handler(clientMsg);
+    } else {
+      await this.emit("error", {
+        error: new Error(`No handler for client ${clientId}`),
+        context: "transport_message"
+      });
+    }
+  }
+  async handleTransportError(error) {
+    await this.emit("error", { error, context: "transport" });
+  }
+  async handleTransportClose(_code, _reason) {
+    if (this.running) {
+      await this.stop();
+    }
+  }
+  async addClient(clientId) {
+    const client = {
+      id: clientId,
+      userId: "",
+      roomId: null,
+      authenticated: false,
+      connectedAt: Date.now()
+    };
+    this.clients.set(clientId, client);
+    this.clientMessageHandlers.set(clientId, this.createClientMessageHandler(clientId));
+    await this.emit("client_connected", { client });
+  }
+  async disconnectClient(clientId, reason) {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      return;
+    }
+    if (client.roomId) {
+      await this.roomManager.leaveRoom(client.roomId, client.userId);
+      await this.emit("client_left_room", { clientId, roomId: client.roomId });
+    }
+    await this.lockManager.releaseUserLocks(client.userId);
+    this.clients.delete(clientId);
+    this.clientMessageHandlers.delete(clientId);
+    await this.emit("client_disconnected", { clientId, reason });
+  }
+  createClientMessageHandler(clientId) {
+    return async (message) => {
+      try {
+        const client = this.clients.get(clientId);
+        if (!client) {
+          return;
+        }
+        switch (message.type) {
+          case "authenticate":
+            await this.handleAuthenticate(clientId, message.payload);
+            break;
+          case "join_room":
+            await this.handleJoinRoom(clientId, message.payload);
+            break;
+          case "leave_room":
+            await this.handleLeaveRoom(clientId);
+            break;
+          case "broadcast_event":
+            await this.handleBroadcastEvent(clientId, message.payload);
+            break;
+          case "request_lock":
+            await this.handleLockRequest(clientId, message.payload);
+            break;
+          case "release_lock":
+            await this.handleLockRelease(clientId, message.payload);
+            break;
+          case "ping":
+            await this.sendToClient(clientId, { type: "pong", timestamp: Date.now() });
+            break;
+          default:
+            await this.sendToClient(clientId, {
+              type: "error",
+              error: `Unknown message type: ${message.type}`
+            });
+        }
+      } catch (error) {
+        await this.sendToClient(clientId, {
+          type: "error",
+          error: error.message
+        });
+        await this.emit("error", { error, context: `client_${clientId}` });
+      }
+    };
+  }
+  async handleAuthenticate(clientId, payload) {
+    if (!this.auth) {
+      await this.sendToClient(clientId, { type: "auth_result", success: false, error: "Authentication not configured" });
+      return;
+    }
+    try {
+      const tokenPayload = await this.auth.validateToken(payload.token);
+      const client = this.clients.get(clientId);
+      if (client) {
+        client.userId = tokenPayload.userId;
+        client.authenticated = true;
+        await this.emit("client_authenticated", { clientId, userId: tokenPayload.userId });
+      }
+      await this.sendToClient(clientId, { type: "auth_result", success: true });
+    } catch (error) {
+      await this.sendToClient(clientId, { type: "auth_result", success: false, error: error.message });
+    }
+  }
+  async handleJoinRoom(clientId, payload) {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      return;
+    }
+    if (payload.token && !client.authenticated) {
+      await this.handleAuthenticate(clientId, { token: payload.token });
+    }
+    if (!client.authenticated) {
+      await this.sendToClient(clientId, { type: "error", error: "Authentication required to join room" });
+      return;
+    }
+    try {
+      if (client.roomId) {
+        await this.roomManager.leaveRoom(client.roomId, client.userId);
+        await this.emit("client_left_room", { clientId, roomId: client.roomId });
+      }
+      let roomState = await this.roomManager.getRoomState(payload.roomId);
+      if (!roomState) {
+        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 });
+      }
+      if (!roomState) {
+        throw new Error("Failed to create or get room state");
+      }
+      const user = {
+        id: client.userId,
+        username: client.userId,
+        status: "online",
+        joinedAt: Date.now(),
+        lastActivity: Date.now(),
+        permissions: roomState.room.permissions || ["read", "write"]
+      };
+      await this.roomManager.joinRoom(payload.roomId, user);
+      client.roomId = payload.roomId;
+      await this.emit("client_joined_room", { clientId, roomId: payload.roomId });
+      await this.sendToClient(clientId, {
+        type: "room_joined",
+        roomId: payload.roomId,
+        state: roomState
+      });
+      const history = await this.roomManager.getEventHistory(payload.roomId, 50);
+      if (history.length > 0) {
+        await this.sendToClient(clientId, {
+          type: "event_history",
+          events: history
+        });
+      }
+    } catch (error) {
+      await this.sendToClient(clientId, { type: "error", error: error.message });
+    }
+  }
+  async handleLeaveRoom(clientId) {
+    const client = this.clients.get(clientId);
+    if (!client || !client.roomId) {
+      return;
+    }
+    const roomId = client.roomId;
+    await this.roomManager.leaveRoom(roomId, client.userId);
+    client.roomId = null;
+    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.roomId !== payload.roomId) {
+      await this.sendToClient(clientId, { type: "error", error: "Not in specified room" });
+      return;
+    }
+    const enrichedEvent = {
+      ...payload.event,
+      metadata: {
+        ...payload.event.metadata,
+        userId: client.userId,
+        timestamp: Date.now(),
+        roomId: payload.roomId
+      }
+    };
+    await this.roomManager.addEventToHistory(payload.roomId, enrichedEvent);
+    await this.roomManager.broadcastToRoom(payload.roomId, enrichedEvent, client.userId);
+    await this.emit("event_broadcast", {
+      roomId: payload.roomId,
+      event: enrichedEvent,
+      fromClientId: clientId
+    });
+  }
+  async handleLockRequest(clientId, payload) {
+    const client = this.clients.get(clientId);
+    if (!client || client.roomId !== payload.roomId) {
+      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.roomManager.broadcastToRoom(payload.roomId, {
+        id: this.generateId(),
+        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 }
+      });
+    } catch (error) {
+      await this.sendToClient(clientId, { type: "lock_denied", request: payload.request, reason: error.message });
+    }
+  }
+  async handleLockRelease(clientId, payload) {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      return;
+    }
+    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 });
+      if (client.roomId) {
+        await this.roomManager.broadcastToRoom(client.roomId, {
+          id: this.generateId(),
+          type: "lock_status",
+          timestamp: Date.now(),
+          userId: client.userId,
+          roomId: client.roomId,
+          data: { lockId: payload.lockId, action: "released" },
+          metadata: { userId: client.userId, timestamp: Date.now(), roomId: client.roomId }
+        });
+      }
+    } catch (error) {
+      await this.sendToClient(clientId, { type: "error", error: error.message });
+    }
+  }
+  async sendToClient(clientId, message) {
+    const transportMessage = {
+      id: this.generateId(),
+      type: "server_message",
+      payload: { clientId, ...message },
+      timestamp: Date.now()
+    };
+    await this.transport.send(transportMessage);
+  }
+  generateId() {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+  }
+  async createRoom(roomId, config) {
+    const room = await this.roomManager.createRoom(roomId, config);
+    await this.emit("room_created", { room });
+    return room;
+  }
+  async deleteRoom(roomId) {
+    await this.roomManager.deleteRoom(roomId);
+    await this.emit("room_deleted", { roomId });
+  }
+  getConnectedClients() {
+    return Array.from(this.clients.values());
+  }
+  getClient(clientId) {
+    return this.clients.get(clientId) || null;
+  }
+  isRunning() {
+    return this.running;
+  }
+}
+// src/server/ServerBuilder.ts
+class ServerBuilder {
+  transport;
+  auth;
+  storage;
+  roomManager;
+  lockManager;
+  defaultRoomConfig;
+  withTransport(transport) {
+    this.transport = transport;
+    return this;
+  }
+  withAuth(auth) {
+    this.auth = auth;
+    return this;
+  }
+  withStorage(storage) {
+    this.storage = storage;
+    return this;
+  }
+  withRoomManager(roomManager) {
+    this.roomManager = roomManager;
+    return this;
+  }
+  withLockManager(lockManager) {
+    this.lockManager = lockManager;
+    return this;
+  }
+  withDefaultRoomConfig(config) {
+    this.defaultRoomConfig = config;
+    return this;
+  }
+  build() {
+    if (!this.transport) {
+      throw new Error("Transport adapter is required");
+    }
+    if (!this.roomManager) {
+      throw new Error("Room manager is required");
+    }
+    if (!this.lockManager) {
+      throw new Error("Lock manager is required");
+    }
+    const config = {
+      transport: this.transport,
+      auth: this.auth,
+      storage: this.storage,
+      roomManager: this.roomManager,
+      lockManager: this.lockManager,
+      defaultRoomConfig: this.defaultRoomConfig || {
+        maxUsers: 50,
+        maxHistory: 100,
+        permissions: ["read", "write"]
+      }
+    };
+    return new BaseServer(config);
+  }
+}
+export {
+  TypedEventEmitter,
+  ServerBuilder,
+  RoomManager,
+  MockTransportAdapter,
+  MockStorageAdapter,
+  MockAuthAdapter,
+  LockManager,
+  DefaultRoomManager,
+  DefaultLockManager,
+  ClientBuilder,
+  BaseServer,
+  BaseClient
+};
+
+//# debugId=FFED7FD7481F9AA464756E2164756E21