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

package/dist/adapters/websocket/WebSocketTransportAdapter.js

@@ -0,0 +1,204 @@
+import { WebSocketServer, WebSocket } from 'ws';
+export class WebSocketTransportAdapter {
+    constructor() {
+        this.state = 'disconnected';
+        this.messageHandlers = new Set();
+        this.errorHandlers = new Set();
+        this.closeHandlers = new Set();
+        // Client management
+        this.clients = new Map();
+        this.mode = 'standalone';
+    }
+    // Standalone mode implementation
+    async connect(url, _options) {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            throw new Error('Already connected or connecting');
+        }
+        this.state = 'connecting';
+        this.serverUrl = url;
+        this.mode = 'standalone';
+        try {
+            // Extract port from URL
+            const urlObj = new URL(url);
+            const port = parseInt(urlObj.port) || (urlObj.protocol === 'wss:' ? 443 : 80);
+            // Create WebSocket server
+            this.wss = new WebSocketServer({ port });
+            this.wss.on('connection', (ws, req) => {
+                this.handleConnection(ws, req);
+            });
+            this.wss.on('error', (error) => {
+                this.errorHandlers.forEach(handler => handler(error));
+            });
+            this.wss.on('close', () => {
+                this.state = 'disconnected';
+                this.closeHandlers.forEach(handler => handler(1000, 'Server closed'));
+            });
+            this.state = 'connected';
+        }
+        catch (error) {
+            this.state = 'disconnected';
+            throw error;
+        }
+    }
+    // Integration mode implementation
+    async attach(server, path = '/ws') {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            throw new Error('Already connected or connecting');
+        }
+        this.state = 'connecting';
+        this.attachedServer = server;
+        this.webSocketPath = path;
+        this.mode = 'integration';
+        try {
+            // Create WebSocket server attached to the existing HTTP server
+            this.wss = new WebSocketServer({
+                server,
+                path,
+                perMessageDeflate: false
+            });
+            this.wss.on('connection', (ws, req) => {
+                this.handleConnection(ws, req);
+            });
+            this.wss.on('error', (error) => {
+                this.errorHandlers.forEach(handler => handler(error));
+            });
+            this.state = 'connected';
+        }
+        catch (error) {
+            this.state = 'disconnected';
+            throw error;
+        }
+    }
+    async attachToWebSocketServer(wss) {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            throw new Error('Already connected or connecting');
+        }
+        this.state = 'connecting';
+        this.attachedWss = wss;
+        this.mode = 'integration';
+        try {
+            this.wss = wss;
+            this.wss.on('connection', (ws, req) => {
+                this.handleConnection(ws, req);
+            });
+            this.wss.on('error', (error) => {
+                this.errorHandlers.forEach(handler => handler(error));
+            });
+            this.state = 'connected';
+        }
+        catch (error) {
+            this.state = 'disconnected';
+            throw error;
+        }
+    }
+    handleConnection(ws, req) {
+        const clientId = this.generateId();
+        const client = {
+            id: clientId,
+            ws,
+            userId: typeof req.headers['x-user-id'] === 'string' ? req.headers['x-user-id'] : undefined
+        };
+        this.clients.set(clientId, client);
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                // Add clientId to message payload for routing
+                const enrichedMessage = {
+                    ...message,
+                    payload: {
+                        ...message.payload,
+                        clientId
+                    }
+                };
+                this.messageHandlers.forEach(handler => handler(enrichedMessage));
+            }
+            catch (error) {
+                this.errorHandlers.forEach(handler => handler(error));
+            }
+        });
+        ws.on('error', (error) => {
+            this.errorHandlers.forEach(handler => handler(error));
+        });
+        ws.on('close', (_code, _reason) => {
+            this.clients.delete(clientId);
+            // Don't emit close for individual clients, only for server shutdown
+        });
+    }
+    async disconnect() {
+        if (this.state === 'disconnected') {
+            return;
+        }
+        this.state = 'disconnecting';
+        // Close all client connections
+        for (const [_clientId, client] of this.clients) {
+            try {
+                client.ws.close(1000, 'Server shutting down');
+            }
+            catch {
+                // Ignore errors when closing individual connections
+            }
+        }
+        this.clients.clear();
+        // Close the WebSocket server (only if we created it)
+        if (this.wss && this.mode === 'standalone') {
+            await new Promise((resolve) => {
+                this.wss.close(() => resolve());
+            });
+        }
+        this.state = 'disconnected';
+        this.wss = undefined;
+        this.attachedServer = undefined;
+        this.attachedWss = undefined;
+    }
+    async send(message) {
+        if (this.state !== 'connected') {
+            throw new Error('Not connected');
+        }
+        // Extract clientId from message payload for routing
+        const payload = message.payload;
+        const { clientId, ...clientMessage } = payload;
+        if (!clientId) {
+            throw new Error('Message must contain clientId in payload for routing');
+        }
+        const client = this.clients.get(clientId);
+        if (!client) {
+            throw new Error(`Client ${clientId} not found`);
+        }
+        if (client.ws.readyState !== WebSocket.OPEN) {
+            throw new Error(`Client ${clientId} connection is not open`);
+        }
+        const messageToSend = {
+            ...message,
+            payload: clientMessage
+        };
+        client.ws.send(JSON.stringify(messageToSend));
+    }
+    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';
+    }
+    // Utility methods
+    getConnectedClients() {
+        return Array.from(this.clients.values());
+    }
+    getClientCount() {
+        return this.clients.size;
+    }
+    getMode() {
+        return this.mode;
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+}

package/dist/adapters/websocket/index.d.ts

@@ -0,0 +1,2 @@
+export { WebSocketTransportAdapter } from './WebSocketTransportAdapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/websocket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/websocket/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/adapters/websocket/index.js

@@ -0,0 +1 @@
+export { WebSocketTransportAdapter } from './WebSocketTransportAdapter';

package/dist/client/BaseClient.d.ts

@@ -0,0 +1,103 @@
+import type { ConnectionState, Event, RoomState, RoomUser, LockRequest, Lock, Credentials } from '../types';
+import type { ITransportAdapter } from '../abstractions/TransportAdapter';
+import type { IAuthAdapter } from '../abstractions/AuthAdapter';
+import type { IStorageAdapter } from '../abstractions/StorageAdapter';
+import { TypedEventEmitter } from '../abstractions/EventEmitter';
+export interface ClientConfig {
+    transport: ITransportAdapter;
+    auth?: IAuthAdapter;
+    storage?: IStorageAdapter;
+    reconnection?: {
+        enabled: boolean;
+        maxAttempts: number;
+        initialDelay: number;
+        maxDelay: number;
+        backoffFactor: number;
+    };
+}
+export interface ClientEvents {
+    connected: {
+        url: string;
+    };
+    disconnected: {
+        code: number;
+        reason: string;
+    };
+    reconnecting: {
+        attempt: number;
+        delay: number;
+    };
+    reconnected: {
+        url: string;
+    };
+    error: {
+        error: Error;
+    };
+    room_joined: {
+        roomId: string;
+        state: RoomState;
+    };
+    room_left: {
+        roomId: string;
+    };
+    event_received: {
+        event: Event;
+    };
+    lock_acquired: {
+        lock: Lock;
+    };
+    lock_released: {
+        lockId: string;
+    };
+    lock_denied: {
+        request: LockRequest;
+        reason: string;
+    };
+    presence_updated: {
+        users: RoomUser[];
+    };
+    [key: string]: unknown;
+}
+export declare class BaseClient extends TypedEventEmitter<ClientEvents> {
+    private transport;
+    private auth?;
+    private storage?;
+    private config;
+    private connectionState;
+    private currentRoomId;
+    private currentRoomState;
+    private authToken;
+    private userId;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private lastConnectionUrl;
+    private lastCredentials;
+    constructor(config: ClientConfig);
+    connect(url: string, credentials?: Credentials): Promise<void>;
+    disconnect(): Promise<void>;
+    reconnect(): Promise<void>;
+    joinRoom(roomId: string): Promise<void>;
+    leaveRoom(): Promise<void>;
+    broadcast(event: Event): Promise<void>;
+    requestLock(request: LockRequest): Promise<void>;
+    releaseLock(lockId: string): Promise<void>;
+    getConnectionState(): ConnectionState;
+    getRoomState(): RoomState | null;
+    getPresence(): RoomUser[];
+    getCurrentRoomId(): string | null;
+    getUserId(): string | null;
+    private handleMessage;
+    private handleError;
+    private handleClose;
+    private handleRoomJoined;
+    private handleRoomLeft;
+    private handleEventBroadcast;
+    private handleLockAcquired;
+    private handleLockReleased;
+    private handleLockDenied;
+    private handlePresenceUpdated;
+    private handleServerError;
+    private scheduleReconnect;
+    private generateId;
+}
+//# sourceMappingURL=BaseClient.d.ts.map

package/dist/client/BaseClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../../src/client/BaseClient.ts"],"names":[],"mappings":"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"}

package/dist/client/BaseClient.js

@@ -0,0 +1,282 @@
+import { TypedEventEmitter } from '../abstractions/EventEmitter';
+export class BaseClient extends TypedEventEmitter {
+    constructor(config) {
+        super();
+        this.connectionState = 'disconnected';
+        this.currentRoomId = null;
+        this.currentRoomState = null;
+        this.authToken = null;
+        this.userId = null;
+        // Reconnection state
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.lastConnectionUrl = null;
+        this.lastCredentials = null;
+        this.config = config;
+        this.transport = config.transport;
+        this.auth = config.auth;
+        this.storage = config.storage;
+        // Set up transport event handlers
+        this.transport.onMessage(this.handleMessage.bind(this));
+        this.transport.onError(this.handleError.bind(this));
+        this.transport.onClose(this.handleClose.bind(this));
+    }
+    // Connection Management
+    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 {
+            // Authenticate if credentials provided and auth adapter available
+            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, // We handle reconnection ourselves
+                ...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: error });
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (this.connectionState === 'disconnected') {
+            return;
+        }
+        this.connectionState = 'disconnecting';
+        // Clear reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Leave room if joined
+        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);
+    }
+    // Room Management
+    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);
+        // Response will be handled in handleMessage
+    }
+    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);
+        // Response will be handled in handleMessage
+        this.currentRoomId = null;
+        this.currentRoomState = null;
+    }
+    // Event Operations
+    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);
+    }
+    // Lock Operations
+    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);
+    }
+    // State Getters
+    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;
+    }
+    // Private Methods
+    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: error });
+            // Error is already emitted, no additional handling needed
+        }
+    }
+    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 });
+            // Attempt reconnection if enabled
+            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) {
+            // Convert array back to Map
+            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 {
+                // Reconnection failed, schedule next attempt
+                this.scheduleReconnect();
+            }
+        }, delay);
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+}

package/dist/client/ClientBuilder.d.ts

@@ -0,0 +1,16 @@
+import type { ITransportAdapter } from '../abstractions/TransportAdapter';
+import type { IAuthAdapter } from '../abstractions/AuthAdapter';
+import type { IStorageAdapter } from '../abstractions/StorageAdapter';
+import { BaseClient, type ClientConfig } from './BaseClient';
+export declare class ClientBuilder {
+    private transport?;
+    private auth?;
+    private storage?;
+    private reconnection?;
+    withTransport(transport: ITransportAdapter): this;
+    withAuth(auth: IAuthAdapter): this;
+    withStorage(storage: IStorageAdapter): this;
+    withReconnection(config: NonNullable<ClientConfig['reconnection']>): this;
+    build(): BaseClient;
+}
+//# sourceMappingURL=ClientBuilder.d.ts.map

package/dist/client/ClientBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientBuilder.d.ts","sourceRoot":"","sources":["../../src/client/ClientBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAE7D,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAC,CAAoB;IACtC,OAAO,CAAC,IAAI,CAAC,CAAe;IAC5B,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,YAAY,CAAC,CAA+B;IAEpD,aAAa,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IAKjD,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAKlC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAK3C,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI;IAKzE,KAAK,IAAI,UAAU;CAoBpB"}

package/dist/client/ClientBuilder.js

@@ -0,0 +1,37 @@
+import { BaseClient } from './BaseClient';
+export class ClientBuilder {
+    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);
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,3 @@
+export { BaseClient, type ClientConfig, type ClientEvents } from './BaseClient';
+export { ClientBuilder } from './ClientBuilder';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,3 @@
+// Client-side implementations
+export { BaseClient } from './BaseClient';
+export { ClientBuilder } from './ClientBuilder';

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { EventType, BaseEvent, FileAction, FileChangeEvent, GitStatusEvent, CommitEvent, BranchChangeEvent, CursorPositionEvent, Event, TokenPayload, AuthResult, CredentialType, OAuthProvider, Credentials, JWTConfig, OAuthConfig, AuthProvider, RoomPermission, Room, RoomUser, UserStatus, RoomState, RoomConfig, LockType, LockPriority, Lock, LockRequest, LockQueueItem, LockState, ConnectionState, ConnectionOptions, Message, MessageHandler, ErrorHandler, CloseHandler } from './types';
+export { ITransportAdapter, IStorageAdapter, StorageOperation, IAuthAdapter, TypedEventEmitter, EventListener, UnsubscribeFn, RoomManager, LockManager, DefaultRoomManager, DefaultLockManager } from './abstractions';
+export { MockTransportAdapter, MockStorageAdapter, MockAuthAdapter } from './adapters/mock';
+export { WebSocketTransportAdapter } from './adapters/websocket';
+export { BaseClient, ClientBuilder, type ClientConfig, type ClientEvents } from './client';
+export { BaseServer, ServerBuilder, type ServerConfig, type ServerEvents, type ConnectedClient } from './server';
+//# sourceMappingURL=index.d.ts.map