@cephalization/phoenix-insight 1.0.0 → 1.0.3

package/dist/server/websocket.js

@@ -1,212 +0,0 @@
-/**
- * WebSocket server for Phoenix Insight CLI.
- * Provides bidirectional communication between the CLI agent and the web UI.
- *
- * Binds to localhost only for security (no external network access).
- * Handles HTTP upgrade requests, manages client connections, and broadcasts messages.
- */
-import { WebSocketServer, WebSocket } from "ws";
-// ============================================================================
-// Phoenix WebSocket Server
-// ============================================================================
-/**
- * Phoenix WebSocket server wrapper providing typed message handling
- * and connection management.
- */
-export class PhoenixWebSocketServer {
-    wss = null;
-    clients = new Set();
-    options;
-    constructor(options = {}) {
-        this.options = {
-            path: "/ws",
-            onMessage: () => { },
-            onConnection: () => { },
-            onDisconnection: () => { },
-            onError: () => { },
-            ...options,
-        };
-    }
-    /**
-     * Attach the WebSocket server to an existing HTTP server.
-     * Uses the upgrade event to handle WebSocket handshakes.
-     */
-    attach(httpServer) {
-        if (this.wss) {
-            throw new Error("WebSocket server is already attached");
-        }
-        // Create WebSocket server with noServer mode to handle upgrade ourselves
-        this.wss = new WebSocketServer({ noServer: true });
-        // Handle HTTP upgrade requests
-        httpServer.on("upgrade", (request, socket, head) => {
-            this.handleUpgrade(request, socket, head);
-        });
-        // Set up WebSocket server event handlers
-        this.setupEventHandlers();
-    }
-    /**
-     * Handle HTTP upgrade request for WebSocket connection.
-     * Only accepts connections on the configured path and from localhost.
-     */
-    handleUpgrade(request, socket, head) {
-        if (!this.wss) {
-            socket.destroy();
-            return;
-        }
-        // Parse the request URL
-        const url = new URL(request.url ?? "/", `http://${request.headers.host}`);
-        // Only accept connections on the configured path
-        if (url.pathname !== this.options.path) {
-            socket.destroy();
-            return;
-        }
-        // Complete the WebSocket handshake
-        this.wss.handleUpgrade(request, socket, head, (ws) => {
-            this.wss?.emit("connection", ws, request);
-        });
-    }
-    /**
-     * Set up event handlers for the WebSocket server.
-     */
-    setupEventHandlers() {
-        if (!this.wss)
-            return;
-        this.wss.on("connection", (ws) => {
-            this.clients.add(ws);
-            this.options.onConnection(ws);
-            ws.on("message", (data) => {
-                this.handleMessage(data, ws);
-            });
-            ws.on("close", (code, reason) => {
-                this.clients.delete(ws);
-                this.options.onDisconnection(ws, code, reason.toString());
-            });
-            ws.on("error", (error) => {
-                this.options.onError(error, ws);
-            });
-        });
-        this.wss.on("error", (error) => {
-            this.options.onError(error);
-        });
-    }
-    /**
-     * Handle incoming message from a client.
-     * Parses JSON and validates message structure before calling handler.
-     */
-    handleMessage(data, client) {
-        try {
-            const rawMessage = data.toString();
-            const parsed = JSON.parse(rawMessage);
-            // Basic validation of message structure
-            if (!parsed || typeof parsed !== "object") {
-                throw new Error("Invalid message structure: expected object");
-            }
-            const obj = parsed;
-            if (!("type" in obj) || typeof obj.type !== "string") {
-                throw new Error("Invalid message structure: missing type field");
-            }
-            const messageType = obj.type;
-            if (messageType !== "query" && messageType !== "cancel") {
-                throw new Error(`Unknown message type: ${messageType}`);
-            }
-            // Now we know this is a valid ClientMessage
-            const message = parsed;
-            this.options.onMessage(message, client);
-        }
-        catch (error) {
-            // Send error message back to the client
-            const errorMessage = {
-                type: "error",
-                payload: {
-                    message: error instanceof Error
-                        ? error.message
-                        : "Failed to parse message",
-                },
-            };
-            this.sendToClient(client, errorMessage);
-        }
-    }
-    /**
-     * Send a message to a specific client.
-     */
-    sendToClient(client, message) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(JSON.stringify(message));
-        }
-    }
-    /**
-     * Broadcast a message to all connected clients.
-     */
-    broadcast(message) {
-        const data = JSON.stringify(message);
-        for (const client of this.clients) {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(data);
-            }
-        }
-    }
-    /**
-     * Broadcast a message to all clients with a specific session ID.
-     * This requires tracking session-to-client mapping externally.
-     * For now, it broadcasts to all clients (to be refined in cli-agent-session).
-     */
-    broadcastToSession(sessionId, message) {
-        // For now, broadcast to all clients.
-        // Session-to-client mapping will be implemented in cli-agent-session task.
-        this.broadcast(message);
-    }
-    /**
-     * Get the number of connected clients.
-     */
-    get clientCount() {
-        return this.clients.size;
-    }
-    /**
-     * Get all connected clients.
-     */
-    getClients() {
-        return new Set(this.clients);
-    }
-    /**
-     * Close the WebSocket server and disconnect all clients.
-     */
-    close() {
-        return new Promise((resolve, reject) => {
-            if (!this.wss) {
-                resolve();
-                return;
-            }
-            // Close all client connections
-            for (const client of this.clients) {
-                client.close(1000, "Server shutting down");
-            }
-            this.clients.clear();
-            // Close the WebSocket server
-            this.wss.close((err) => {
-                this.wss = null;
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-}
-// ============================================================================
-// Factory Function
-// ============================================================================
-/**
- * Create and attach a WebSocket server to an HTTP server.
- * The WebSocket server binds to localhost only (through the HTTP server).
- *
- * @param httpServer - HTTP server to attach WebSocket handling to
- * @param options - WebSocket server options
- * @returns PhoenixWebSocketServer instance
- */
-export function createWebSocketServer(httpServer, options) {
-    const server = new PhoenixWebSocketServer(options);
-    server.attach(httpServer);
-    return server;
-}

package/dist/snapshot/client.js

@@ -1,74 +0,0 @@
-import { createClient } from "@arizeai/phoenix-client";
-export class PhoenixClientError extends Error {
-    code;
-    originalError;
-    constructor(message, code, originalError) {
-        super(message);
-        this.name = "PhoenixClientError";
-        this.code = code;
-        this.originalError = originalError;
-    }
-}
-/**
- * Creates a wrapped Phoenix client with error handling
- */
-export function createPhoenixClient(config = {}) {
-    const headers = {};
-    if (config.apiKey) {
-        headers["api_key"] = config.apiKey;
-    }
-    const clientOptions = {
-        options: {
-            baseUrl: config.baseURL,
-            headers: Object.keys(headers).length > 0 ? headers : undefined,
-        },
-    };
-    return createClient(clientOptions);
-}
-/**
- * Wraps an async operation with standardized error handling
- */
-export async function withErrorHandling(operation, context) {
-    try {
-        return await operation();
-    }
-    catch (error) {
-        // Network errors
-        if (error instanceof TypeError && error.message.includes("fetch")) {
-            throw new PhoenixClientError(`Network error during ${context}: Unable to connect to Phoenix server`, "NETWORK_ERROR", error);
-        }
-        // HTTP errors from the middleware
-        if (error instanceof Error && error.message.includes(": ")) {
-            const parts = error.message.split(": ", 2);
-            if (parts.length === 2 && parts[1]) {
-                const [url, statusInfo] = parts;
-                const statusParts = statusInfo.split(" ");
-                const statusCode = statusParts[0];
-                const statusText = statusParts.slice(1).join(" ");
-                if (statusCode === "401" || statusCode === "403") {
-                    throw new PhoenixClientError(`Authentication error during ${context}: ${statusText}`, "AUTH_ERROR", error);
-                }
-                if (statusCode && statusCode.startsWith("4")) {
-                    throw new PhoenixClientError(`Client error during ${context}: ${statusCode} ${statusText}`, "INVALID_RESPONSE", error);
-                }
-                if (statusCode && statusCode.startsWith("5")) {
-                    throw new PhoenixClientError(`Server error during ${context}: ${statusCode} ${statusText}`, "NETWORK_ERROR", error);
-                }
-            }
-        }
-        // Unknown errors
-        throw new PhoenixClientError(`Unexpected error during ${context}: ${error instanceof Error ? error.message : String(error)}`, "UNKNOWN_ERROR", error);
-    }
-}
-/**
- * Helper to safely extract data from API responses
- */
-export function extractData(response) {
-    if (response.error) {
-        throw response.error;
-    }
-    if (!response.data) {
-        throw new PhoenixClientError("Invalid API response: missing data", "INVALID_RESPONSE");
-    }
-    return response.data;
-}