sudocode 1.1.20 → 1.1.22

package/node_modules/@sudocode-ai/local-server/dist/services/websocket.js

@@ -1,758 +0,0 @@
-import { WebSocketServer, WebSocket } from "ws";
-import { randomUUID } from "crypto";
-import { getTTSSidecarManager, } from "./tts-sidecar-manager.js";
-const LOG_CONNECTIONS = false;
-/**
- * WebSocket server manager
- */
-class WebSocketManager {
-    wss = null;
-    clients = new Map();
-    heartbeatInterval = null;
-    HEARTBEAT_INTERVAL = 30000; // 30 seconds
-    /** Callbacks to invoke when a client disconnects */
-    disconnectCallbacks = new Set();
-    /**
-     * Initialize the WebSocket server
-     * @param server HTTP server instance
-     * @param path WebSocket path (default: "/ws")
-     * @param allowReinit Allow re-initialization after shutdown (default: false)
-     */
-    init(server, path = "/ws", allowReinit = false) {
-        if (this.wss) {
-            if (allowReinit) {
-                console.warn("[websocket] WebSocket server already initialized, but re-initialization is allowed");
-                // Don't return, allow re-initialization
-            }
-            else {
-                console.warn("[websocket] WebSocket server already initialized");
-                return;
-            }
-        }
-        try {
-            this.wss = new WebSocketServer({ server, path });
-            // Verify the WebSocket server was created successfully
-            if (!this.wss) {
-                throw new Error("Failed to create WebSocket server");
-            }
-            // Add error handler to catch initialization issues
-            this.wss.on("error", (error) => {
-                console.error(`[websocket] WebSocket server error:`, error);
-                throw new Error(`WebSocket server error: ${error.message}`);
-            });
-            console.log(`[websocket] WebSocket server initialized on path: ${path}`);
-            this.wss.on("connection", this.handleConnection.bind(this));
-            this.startHeartbeat();
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`[websocket] Failed to initialize WebSocket server:`, errorMessage);
-            // Clean up on failure
-            this.wss = null;
-            throw new Error(`Failed to initialize WebSocket server on path ${path}: ${errorMessage}`);
-        }
-    }
-    /**
-     * Handle new WebSocket connection
-     */
-    handleConnection(ws, _req) {
-        const clientId = randomUUID();
-        const client = {
-            id: clientId,
-            ws,
-            subscriptions: new Set(),
-            isAlive: true,
-            connectedAt: new Date(),
-        };
-        this.clients.set(clientId, client);
-        if (LOG_CONNECTIONS) {
-            console.log(`[websocket] Client connected: ${clientId} (total: ${this.clients.size})`);
-        }
-        // Set up event handlers
-        ws.on("message", (data) => this.handleMessage(clientId, data));
-        ws.on("close", () => this.handleDisconnection(clientId));
-        ws.on("error", (error) => this.handleError(clientId, error));
-        ws.on("pong", () => this.handlePong(clientId));
-        // Send welcome message
-        this.sendToClient(clientId, {
-            type: "pong",
-            message: "Connected to sudocode server",
-        });
-    }
-    /**
-     * Handle client disconnection
-     */
-    handleDisconnection(clientId) {
-        const client = this.clients.get(clientId);
-        if (client) {
-            if (LOG_CONNECTIONS) {
-                console.log(`[websocket] Client disconnected: ${clientId} (subscriptions: ${client.subscriptions.size})`);
-            }
-            // Notify disconnect callbacks before removing the client
-            // Clone subscriptions since we're about to delete the client
-            const subscriptions = new Set(client.subscriptions);
-            for (const callback of this.disconnectCallbacks) {
-                try {
-                    callback(clientId, subscriptions);
-                }
-                catch (error) {
-                    console.error(`[websocket] Error in disconnect callback for ${clientId}:`, error);
-                }
-            }
-            this.clients.delete(clientId);
-        }
-    }
-    /**
-     * Register a callback to be invoked when a client disconnects
-     * @param callback - Function to call with clientId and subscriptions
-     * @returns Function to unregister the callback
-     */
-    onDisconnect(callback) {
-        this.disconnectCallbacks.add(callback);
-        return () => {
-            this.disconnectCallbacks.delete(callback);
-        };
-    }
-    /**
-     * Check if any client is subscribed to a specific entity
-     * @param projectId - Project ID
-     * @param entityType - Entity type (execution, issue, etc.)
-     * @param entityId - Entity ID
-     * @returns true if at least one client is subscribed
-     */
-    hasSubscribers(projectId, entityType, entityId) {
-        const subscription = `${projectId}:${entityType}:${entityId}`;
-        const typeSubscription = `${projectId}:${entityType}:*`;
-        const allSubscription = `${projectId}:all`;
-        for (const client of this.clients.values()) {
-            if (client.ws.readyState !== WebSocket.OPEN) {
-                continue;
-            }
-            if (client.subscriptions.has(subscription) ||
-                client.subscriptions.has(typeSubscription) ||
-                client.subscriptions.has(allSubscription)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Handle client errors
-     */
-    handleError(clientId, error) {
-        console.error(`[websocket] Client error (${clientId}):`, error.message);
-    }
-    /**
-     * Handle pong response from client
-     */
-    handlePong(clientId) {
-        const client = this.clients.get(clientId);
-        if (client) {
-            client.isAlive = true;
-        }
-    }
-    /**
-     * Handle incoming messages from clients
-     */
-    handleMessage(clientId, data) {
-        const client = this.clients.get(clientId);
-        if (!client) {
-            return;
-        }
-        try {
-            const message = JSON.parse(data.toString());
-            switch (message.type) {
-                case "subscribe":
-                    this.handleSubscribe(clientId, message);
-                    break;
-                case "unsubscribe":
-                    this.handleUnsubscribe(clientId, message);
-                    break;
-                case "ping":
-                    this.sendToClient(clientId, { type: "pong" });
-                    break;
-                case "tts_request":
-                    this.handleTTSRequest(clientId, message);
-                    break;
-                default:
-                    this.sendToClient(clientId, {
-                        type: "error",
-                        message: `Unknown message type: ${message.type}`,
-                    });
-            }
-        }
-        catch (error) {
-            console.error(`[websocket] Failed to parse message from ${clientId}:`, error);
-            this.sendToClient(clientId, {
-                type: "error",
-                message: "Invalid message format",
-            });
-        }
-    }
-    /**
-     * Handle subscription request
-     */
-    handleSubscribe(clientId, message) {
-        const client = this.clients.get(clientId);
-        if (!client) {
-            return;
-        }
-        let subscription;
-        const projectId = message.project_id;
-        if (!projectId) {
-            this.sendToClient(clientId, {
-                type: "error",
-                message: "project_id is required for subscriptions",
-            });
-            return;
-        }
-        if (message.entity_type === "all") {
-            // Subscribe to all updates for a project
-            subscription = `${projectId}:all`;
-        }
-        else if (message.entity_type && message.entity_id) {
-            // Subscribe to a specific entity in a project
-            subscription = `${projectId}:${message.entity_type}:${message.entity_id}`;
-        }
-        else if (message.entity_type) {
-            // Subscribe to all entities of a type in a project
-            subscription = `${projectId}:${message.entity_type}:*`;
-        }
-        else {
-            this.sendToClient(clientId, {
-                type: "error",
-                message: "Invalid subscription request",
-            });
-            return;
-        }
-        client.subscriptions.add(subscription);
-        if (LOG_CONNECTIONS) {
-            console.log(`[websocket] Client ${clientId} subscribed to: ${subscription}`);
-        }
-        this.sendToClient(clientId, {
-            type: "subscribed",
-            subscription,
-            message: `Subscribed to ${subscription}`,
-        });
-    }
-    /**
-     * Handle unsubscription request
-     */
-    handleUnsubscribe(clientId, message) {
-        const client = this.clients.get(clientId);
-        if (!client) {
-            return;
-        }
-        let subscription;
-        const projectId = message.project_id;
-        if (!projectId) {
-            this.sendToClient(clientId, {
-                type: "error",
-                message: "project_id is required for unsubscription",
-            });
-            return;
-        }
-        if (message.entity_type === "all") {
-            subscription = `${projectId}:all`;
-        }
-        else if (message.entity_type && message.entity_id) {
-            subscription = `${projectId}:${message.entity_type}:${message.entity_id}`;
-        }
-        else if (message.entity_type) {
-            subscription = `${projectId}:${message.entity_type}:*`;
-        }
-        else {
-            this.sendToClient(clientId, {
-                type: "error",
-                message: "Invalid unsubscription request",
-            });
-            return;
-        }
-        client.subscriptions.delete(subscription);
-        if (LOG_CONNECTIONS) {
-            console.log(`[websocket] Client ${clientId} unsubscribed from: ${subscription}`);
-        }
-        this.sendToClient(clientId, {
-            type: "unsubscribed",
-            subscription,
-            message: `Unsubscribed from ${subscription}`,
-        });
-    }
-    /**
-     * Handle TTS request from client
-     * Streams audio chunks from the sidecar back to the client
-     */
-    async handleTTSRequest(clientId, message) {
-        const client = this.clients.get(clientId);
-        if (!client) {
-            return;
-        }
-        // Validate required fields
-        const requestId = message.request_id;
-        const text = message.text;
-        if (!requestId) {
-            this.sendToClient(clientId, {
-                type: "tts_error",
-                request_id: requestId,
-                error: "request_id is required",
-                recoverable: false,
-                fallback: true,
-            });
-            return;
-        }
-        if (!text) {
-            this.sendToClient(clientId, {
-                type: "tts_error",
-                request_id: requestId,
-                error: "text is required",
-                recoverable: false,
-                fallback: true,
-            });
-            return;
-        }
-        // Get sidecar manager
-        const sidecar = getTTSSidecarManager();
-        // Set up event listeners for this specific request
-        let chunkCount = 0;
-        const startTime = Date.now();
-        const audioHandler = (response) => {
-            if (response.id !== requestId)
-                return;
-            chunkCount++;
-            this.sendToClient(clientId, {
-                type: "tts_audio",
-                request_id: requestId,
-                chunk: response.chunk,
-                index: response.index,
-                is_final: false,
-            });
-        };
-        const doneHandler = (response) => {
-            if (response.id !== requestId)
-                return;
-            const durationMs = Date.now() - startTime;
-            this.sendToClient(clientId, {
-                type: "tts_end",
-                request_id: requestId,
-                total_chunks: response.total_chunks,
-                duration_ms: durationMs,
-            });
-            cleanup();
-        };
-        const errorHandler = (response) => {
-            if (response.id !== requestId)
-                return;
-            this.sendToClient(clientId, {
-                type: "tts_error",
-                request_id: requestId,
-                error: response.error,
-                recoverable: response.recoverable,
-                fallback: !response.recoverable,
-            });
-            cleanup();
-        };
-        const cleanup = () => {
-            sidecar.off("audio", audioHandler);
-            sidecar.off("done", doneHandler);
-            sidecar.off("error", errorHandler);
-        };
-        // Subscribe to sidecar events
-        sidecar.on("audio", audioHandler);
-        sidecar.on("done", doneHandler);
-        sidecar.on("error", errorHandler);
-        try {
-            // Ensure sidecar is ready (installs if needed, starts if not running)
-            await sidecar.ensureReady();
-            // Send generate request to sidecar
-            await sidecar.generate({
-                id: requestId,
-                text: text,
-                voice: message.voice,
-                speed: message.speed,
-            });
-        }
-        catch (error) {
-            // Sidecar unavailable - tell client to fallback to browser TTS
-            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            console.error(`[websocket] TTS request failed for ${clientId}:`, errorMessage);
-            this.sendToClient(clientId, {
-                type: "tts_error",
-                request_id: requestId,
-                error: `TTS sidecar unavailable: ${errorMessage}`,
-                recoverable: false,
-                fallback: true,
-            });
-            cleanup();
-        }
-    }
-    /**
-     * Send a message to a specific client
-     */
-    sendToClient(clientId, message) {
-        const client = this.clients.get(clientId);
-        if (!client || client.ws.readyState !== WebSocket.OPEN) {
-            return;
-        }
-        try {
-            client.ws.send(JSON.stringify(message));
-        }
-        catch (error) {
-            console.error(`[websocket] Failed to send message to ${clientId}:`, error);
-        }
-    }
-    /**
-     * Broadcast a message to all subscribed clients for a specific project
-     */
-    broadcast(projectId, entityType, entityId, message) {
-        const subscription = `${projectId}:${entityType}:${entityId}`;
-        const typeSubscription = `${projectId}:${entityType}:*`;
-        const allSubscription = `${projectId}:all`;
-        let sentCount = 0;
-        // Ensure message includes projectId
-        message.projectId = projectId;
-        this.clients.forEach((client) => {
-            if (client.ws.readyState !== WebSocket.OPEN) {
-                return;
-            }
-            // Check if client is subscribed to this specific entity, entity type, or all for this project
-            if (client.subscriptions.has(subscription) ||
-                client.subscriptions.has(typeSubscription) ||
-                client.subscriptions.has(allSubscription)) {
-                try {
-                    client.ws.send(JSON.stringify(message));
-                    sentCount++;
-                }
-                catch (error) {
-                    console.error(`[websocket] Failed to broadcast to ${client.id}:`, error);
-                }
-            }
-        });
-        if (sentCount > 0) {
-            console.log(`[websocket] Broadcasted ${message.type} for ${subscription} to ${sentCount} clients`);
-        }
-    }
-    /**
-     * Broadcast a relationship or feedback update for a specific project
-     * These don't have a specific entity type in the subscription, so we broadcast to 'all' subscribers for the project
-     */
-    broadcastGeneric(projectId, message) {
-        const allSubscription = `${projectId}:all`;
-        let sentCount = 0;
-        // Ensure message includes projectId
-        message.projectId = projectId;
-        this.clients.forEach((client) => {
-            if (client.ws.readyState !== WebSocket.OPEN) {
-                return;
-            }
-            // Only send to clients subscribed to 'all' for this project
-            if (client.subscriptions.has(allSubscription)) {
-                try {
-                    client.ws.send(JSON.stringify(message));
-                    sentCount++;
-                }
-                catch (error) {
-                    console.error(`[websocket] Failed to broadcast to ${client.id}:`, error);
-                }
-            }
-        });
-        if (sentCount > 0) {
-            console.log(`[websocket] Broadcasted ${message.type} for project ${projectId} to ${sentCount} clients`);
-        }
-    }
-    /**
-     * Broadcast project lifecycle events (opened/closed)
-     */
-    broadcastProjectEvent(projectId, event, data) {
-        const allSubscription = `${projectId}:all`;
-        const message = {
-            type: event === "opened" ? "project_opened" : "project_closed",
-            projectId,
-            data,
-        };
-        let sentCount = 0;
-        this.clients.forEach((client) => {
-            if (client.ws.readyState !== WebSocket.OPEN) {
-                return;
-            }
-            // Send to clients subscribed to this project
-            if (client.subscriptions.has(allSubscription)) {
-                try {
-                    client.ws.send(JSON.stringify(message));
-                    sentCount++;
-                }
-                catch (error) {
-                    console.error(`[websocket] Failed to broadcast to ${client.id}:`, error);
-                }
-            }
-        });
-        if (sentCount > 0) {
-            console.log(`[websocket] Broadcasted project_${event} for ${projectId} to ${sentCount} clients`);
-        }
-    }
-    /**
-     * Start the heartbeat mechanism to detect dead connections
-     */
-    startHeartbeat() {
-        if (this.heartbeatInterval) {
-            return;
-        }
-        this.heartbeatInterval = setInterval(() => {
-            this.clients.forEach((client, clientId) => {
-                if (!client.isAlive) {
-                    console.log(`[websocket] Terminating dead connection: ${clientId}`);
-                    client.ws.terminate();
-                    this.clients.delete(clientId);
-                    return;
-                }
-                client.isAlive = false;
-                try {
-                    client.ws.ping();
-                }
-                catch (error) {
-                    console.error(`[websocket] Failed to ping ${clientId}:`, error);
-                }
-            });
-        }, this.HEARTBEAT_INTERVAL);
-        console.log(`[websocket] Heartbeat started (interval: ${this.HEARTBEAT_INTERVAL}ms)`);
-    }
-    /**
-     * Stop the heartbeat mechanism
-     */
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-            console.log("[websocket] Heartbeat stopped");
-        }
-    }
-    /**
-     * Get the WebSocket server instance
-     */
-    getServer() {
-        return this.wss;
-    }
-    /**
-     * Get statistics about connected clients
-     */
-    getStats() {
-        return {
-            totalClients: this.clients.size,
-            clients: Array.from(this.clients.values()).map((client) => ({
-                id: client.id,
-                subscriptions: Array.from(client.subscriptions),
-                connectedAt: client.connectedAt.toISOString(),
-                isAlive: client.isAlive,
-            })),
-        };
-    }
-    /**
-     * Gracefully shutdown the WebSocket server
-     */
-    async shutdown() {
-        console.log("[websocket] Shutting down WebSocket server...");
-        this.stopHeartbeat();
-        // Close all client connections
-        this.clients.forEach((client) => {
-            try {
-                client.ws.close(1000, "Server shutting down");
-            }
-            catch (error) {
-                console.error(`[websocket] Error closing client ${client.id}:`, error);
-            }
-        });
-        this.clients.clear();
-        // Close the WebSocket server
-        if (this.wss) {
-            return new Promise((resolve) => {
-                this.wss.close(() => {
-                    console.log("[websocket] WebSocket server closed");
-                    this.wss = null;
-                    resolve();
-                });
-            });
-        }
-    }
-}
-// Export singleton instance
-export const websocketManager = new WebSocketManager();
-/**
- * Initialize the WebSocket server
- */
-export function initWebSocketServer(server, path) {
-    websocketManager.init(server, path);
-}
-/**
- * Broadcast issue updates to subscribed clients for a specific project
- */
-export function broadcastIssueUpdate(projectId, issueId, action, data) {
-    websocketManager.broadcast(projectId, "issue", issueId, {
-        type: `issue_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast spec updates to subscribed clients for a specific project
- */
-export function broadcastSpecUpdate(projectId, specId, action, data) {
-    websocketManager.broadcast(projectId, "spec", specId, {
-        type: `spec_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast feedback updates to subscribed clients for a specific project
- */
-export function broadcastFeedbackUpdate(projectId, action, data) {
-    websocketManager.broadcastGeneric(projectId, {
-        type: `feedback_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast relationship updates to subscribed clients for a specific project
- */
-export function broadcastRelationshipUpdate(projectId, action, data) {
-    websocketManager.broadcastGeneric(projectId, {
-        type: `relationship_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast execution updates to subscribed clients for a specific project
- * Also optionally broadcasts to parent issue subscribers
- *
- * @param projectId - ID of the project
- * @param executionId - ID of the execution
- * @param action - The action performed on the execution
- * @param data - Execution data to broadcast
- * @param issueId - Optional issue ID to also broadcast to issue subscribers
- */
-export function broadcastExecutionUpdate(projectId, executionId, action, data, issueId) {
-    // Primary broadcast to execution subscribers
-    websocketManager.broadcast(projectId, "execution", executionId, {
-        type: `execution_${action}`,
-        data,
-    });
-    // Secondary broadcast to issue subscribers if issueId provided
-    // This allows clients viewing an issue to see its execution updates
-    // without subscribing to each individual execution
-    if (issueId) {
-        websocketManager.broadcast(projectId, "issue", issueId, {
-            type: `execution_${action}`,
-            data,
-        });
-    }
-}
-/**
- * Broadcast persistent session state change events
- *
- * Used for session_waiting, session_paused, and session_ended events.
- *
- * @param projectId - ID of the project
- * @param executionId - ID of the execution with the persistent session
- * @param event - The session event type
- * @param data - Event-specific data (promptCount for pending/paused, reason for ended)
- */
-export function broadcastSessionEvent(projectId, executionId, event, data) {
-    websocketManager.broadcast(projectId, "execution", executionId, {
-        type: event,
-        data: {
-            executionId,
-            ...data,
-        },
-    });
-}
-/**
- * Broadcast voice narration event to subscribed clients for a specific execution
- *
- * This is used to emit voice narration events during execution streaming.
- * Clients can subscribe to execution events to receive narration updates.
- *
- * @param projectId - ID of the project
- * @param executionId - ID of the execution emitting the narration
- * @param narrationData - Voice narration event data
- * @param issueId - Optional issue ID to also broadcast to issue subscribers
- */
-export function broadcastVoiceNarration(projectId, executionId, narrationData, issueId) {
-    console.log(`[websocket] broadcastVoiceNarration called:`, {
-        projectId,
-        executionId,
-        text: narrationData.text.substring(0, 50),
-        category: narrationData.category,
-        issueId,
-    });
-    // Primary broadcast to execution subscribers
-    websocketManager.broadcast(projectId, "execution", executionId, {
-        type: "voice_narration",
-        data: {
-            executionId,
-            ...narrationData,
-        },
-    });
-    // Secondary broadcast to issue subscribers if issueId provided
-    if (issueId) {
-        websocketManager.broadcast(projectId, "issue", issueId, {
-            type: "voice_narration",
-            data: {
-                executionId,
-                ...narrationData,
-            },
-        });
-    }
-}
-/**
- * Broadcast project opened event to subscribed clients
- */
-export function broadcastProjectOpened(projectId, data) {
-    websocketManager.broadcastProjectEvent(projectId, "opened", data);
-}
-/**
- * Broadcast project closed event to subscribed clients
- */
-export function broadcastProjectClosed(projectId, data) {
-    websocketManager.broadcastProjectEvent(projectId, "closed", data);
-}
-/**
- * Get the WebSocket server instance
- */
-export function getWebSocketServer() {
-    return websocketManager.getServer();
-}
-/**
- * Get WebSocket server statistics
- */
-export function getWebSocketStats() {
-    return websocketManager.getStats();
-}
-/**
- * Shutdown the WebSocket server
- */
-export async function shutdownWebSocketServer() {
-    await websocketManager.shutdown();
-}
-/**
- * Broadcast workflow updates to subscribed clients for a specific project
- */
-export function broadcastWorkflowUpdate(projectId, workflowId, action, data) {
-    websocketManager.broadcast(projectId, "workflow", workflowId, {
-        type: `workflow_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast workflow step updates to subscribed clients for a specific project
- */
-export function broadcastWorkflowStepUpdate(projectId, workflowId, action, data) {
-    websocketManager.broadcast(projectId, "workflow", workflowId, {
-        type: `workflow_step_${action}`,
-        data,
-    });
-}
-/**
- * Broadcast a generic message to all subscribers for a specific project
- * Used for integration sync events and other project-wide notifications
- */
-export function broadcastToProject(projectId, message) {
-    websocketManager.broadcastGeneric(projectId, message);
-}
-//# sourceMappingURL=websocket.js.map