From 7b174ab2a7c54d3e25a56530a2179848db2d46c0 Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Sun, 24 Aug 2025 21:16:36 -0700 Subject: First pass at websocket server for editing. --- indra/newview/llscripteditorws.cpp | 608 +++++++++++++++++++++++++++++++++++++ 1 file changed, 608 insertions(+) create mode 100644 indra/newview/llscripteditorws.cpp (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp new file mode 100644 index 0000000000..503624d15a --- /dev/null +++ b/indra/newview/llscripteditorws.cpp @@ -0,0 +1,608 @@ +/** + * @file llscripteditorws.cpp + * + * $LicenseInfo:firstyear=2002&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2010, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +/* + * ============================================================================ + * WEBSOCKET MESSAGE FORMAT SPECIFICATION + * ============================================================================ + * + * This WebSocket implementation uses a structured JSON message format for + * communication between the Second Life viewer and external script editors. + * All messages are encoded as UTF-8 JSON strings. + * + * ## BASE MESSAGE STRUCTURE + * + * Every WebSocket message follows this mandatory structure: + * + * ```json + * { + * "command": "message_type_identifier", // REQUIRED: Command/message type + * "data": { // OPTIONAL: Command-specific payload + * // ... command-specific fields ... + * }, + * "timestamp": "2025-01-27T15:30:00Z", // OPTIONAL: ISO8601 timestamp + * "session_id": "uuid-string", // OPTIONAL: Session identifier + * "message_id": "unique-id" // OPTIONAL: For request/response correlation + * } + * ``` + * + * ## MESSAGE TYPES + * + * ### 1. SERVER-TO-CLIENT MESSAGES + * + * #### capabilities + * Sent immediately when client connects to announce server capabilities. + * ```json + * { + * "command": "capabilities", + * "data": { + * "server_name": "Second Life Script Editor WebSocket Server", + * "server_version": "1.0.0", + * "protocol_version": "1.0", + * "viewer_name": "Second Life", + * "viewer_version": "Second Life Release 6.4.26", + * "session_id": "generated-uuid", + * "timestamp": "2025-01-27T15:30:00Z", + * "capabilities": ["script_editing", "compilation", "metadata", ...], + * "supported_languages": ["lsl", "luau"], + * "features": { + * "live_compilation": true, + * "debugging": false, + * "breakpoints": false + * } + * } + * } + * ``` + * + * #### error + * Sent when message processing fails or protocol violations occur. + * ```json + * { + * "command": "error", + * "data": { + * "error_code": "PARSE_ERROR|INVALID_MESSAGE|UNKNOWN_MESSAGE_TYPE", + * "error_message": "Human-readable error description" + * } + * } + * ``` + * + * ### 2. CLIENT-TO-SERVER MESSAGES + * + * #### connect + * Client handshake message to establish connection and negotiate capabilities. + * ```json + * { + * "command": "connect", + * "data": { + * "client_name": "VS Code LSL Extension", + * "client_version": "1.2.3", + * "protocol_version": "1.0", + * "capabilities": ["script_editing", "syntax_highlighting"], + * "supported_languages": ["lsl", "luau"], + * "features": { + * "auto_completion": true, + * "live_preview": false + * }, + * "session_id": "optional-client-provided-uuid" + * } + * } + * ``` + * + * ### 3. BIDIRECTIONAL MESSAGES + * + * #### connect_ack + * Server response to client connect message. + * ```json + * { + * "command": "connect_ack", + * "data": { + * "status": "connected|rejected", + * "message": "Connection established successfully", + * "session_id": "established-session-uuid", + * "timestamp": "2025-01-27T15:30:00Z", + * "mutual_capabilities": ["script_editing", "compilation"], + * "supported_languages": ["lsl", "luau"], + * "max_script_size": 65536, + * "heartbeat_interval": 30, + * // For rejected connections: + * "error": "incompatible_protocol|missing_capabilities|connection_failed" + * } + * } + * ``` + * + * ## FUTURE MESSAGE TYPES (Planned) + * + * The following message types are referenced in the protocol design but not + * yet implemented: + * + * - `script_updated`: Editor notifies viewer of script content changes + * - `save_request`: Editor requests script save to SL servers + * - `compile_request`: Editor requests script compilation + * - `script_content`: Viewer sends full script content to editor + * - `compile_result`: Viewer sends compilation results to editor + * - `save_result`: Viewer sends save operation results to editor + * - `metadata`: Script and object metadata exchange + * - `ping`/`pong`: Connection health check messages + * - `editor_ready`: Editor initialization complete notification + * + * ## PROTOCOL RULES + * + * 1. **Encoding**: All messages must be valid UTF-8 JSON + * 2. **Required Fields**: Every message MUST have a "command" field + * 3. **Case Sensitivity**: All field names are case-sensitive + * 4. **Protocol Version**: Currently only "1.0" is supported + * 5. **Error Handling**: Invalid messages trigger "error" responses + * 6. **Connection Flow**: Client must send "connect" before other commands + * 7. **Session Management**: session_id tracks individual editor sessions + * 8. **Capability Negotiation**: Features limited to mutual capabilities + * + * ## ERROR CODES + * + * - `PARSE_ERROR`: Invalid JSON syntax + * - `PARSE_EXCEPTION`: JSON parsing threw exception + * - `INVALID_MESSAGE`: Missing required "command" field + * - `UNKNOWN_MESSAGE_TYPE`: Unrecognized command type + * - `INCOMPATIBLE_PROTOCOL`: Unsupported protocol version + * - `MISSING_CAPABILITIES`: Required capabilities not supported + * - `CONNECTION_FAILED`: General connection establishment failure + * + * ## IMPLEMENTATION NOTES + * + * - Messages are parsed using boost::json and converted to LLSD internally + * - All timestamps use ISO 8601 format in UTC timezone + * - UUIDs are generated using LLUUID::generateNewID() for session tracking + * - Maximum script size is currently limited to 65536 bytes + * - WebSocket server binds to localhost only for security by default + * - Protocol designed for extensibility with additional message types + * + * ============================================================================ + */ + + +#include "llviewerprecompiledheaders.h" +#include "llscripteditorws.h" +#include "llpreviewscript.h" +#include "llappviewer.h" +#include "lltrans.h" +#include "lldate.h" +#include "llerror.h" +#include "lluuid.h" +#include "llsdjson.h" +#include + +//------------------------------------------------------------------------ + +LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string_view name, U16 port, bool local_only): + LLWebsocketMgr::WSServer(name, port, local_only) +{ +} + +LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(WSServer::ptr_t server, LLWebsocketMgr::connection_h handle) +{ + return std::make_shared(server, handle); +} + +//------------------------------------------------------------------------ +void LLScriptEditorWSServer::onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) +{ + LL_INFOS("ScriptEditorWS") << "New script editor client connected" << LL_ENDL; + + // Build capabilities message to send to the newly connected external editor + LLSD capabilities_message; + capabilities_message["command"] = "capabilities"; + + LLSD& data = capabilities_message["data"]; + + // Server identification and version information + data["server_name"] = "Second Life Script Editor WebSocket Server"; + data["server_version"] = "1.0.0"; + data["protocol_version"] = "1.0"; + + // Viewer information + data["viewer_name"] = LLTrans::getString("APP_NAME"); + data["viewer_version"] = LLAppViewer::instance()->getSecondLifeTitle(); + + // Session information + data["session_id"] = LLUUID::generateNewID().asString(); + data["timestamp"] = LLDate::now().asString(); + + // Server capabilities - what the viewer/server supports + LLSD capabilities = LLSD::emptyArray(); + capabilities.append("script_editing"); // Basic script content editing + capabilities.append("script_synchronization"); // Real-time sync between viewer and editor + capabilities.append("compilation"); // Compile results with errors/warnings + capabilities.append("metadata"); // Script and object metadata + capabilities.append("syntax_highlighting"); // LSL/Luau syntax information + capabilities.append("error_reporting"); // Detailed error reporting + + data["capabilities"] = capabilities; + + // Language support information + LLSD languages = LLSD::emptyArray(); + languages.append("lsl"); // Linden Scripting Language + languages.append("luau"); // Luau scripting language + data["supported_languages"] = languages; + + // Feature flags + LLSD features; + features["live_compilation"] = true; + features["debugging"] = false; // Not implemented yet + features["breakpoints"] = false; // Not implemented yet + data["features"] = features; + + // Send the capabilities message to the newly connected client + if (connection->sendMessage(capabilities_message)) + { + LL_INFOS("ScriptEditorWS") << "Sent capabilities message to new client" << LL_ENDL; + } + else + { + LL_WARNS("ScriptEditorWS") << "Failed to send capabilities message to new client" << LL_ENDL; + } +} + +void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnection::ptr_t& connection) +{ + LL_INFOS("ScriptEditorWS") << "Script editor client disconnected" << LL_ENDL; + + // Remove from active connections + auto script_connection = std::dynamic_pointer_cast(connection); + if (script_connection) + { + mActiveConnections.erase(script_connection); + + // Remove from any script associations + LL_INFOS("ScriptEditorWS") << "Removed connection from active connections. Total: " + << mActiveConnections.size() << LL_ENDL; + } +} + +//------------------------------------------------------------------------ +bool LLScriptEditorWSServer::associateEditor(const LLHandle& editor_handle, const std::string& script_id) +{ + if (!editor_handle.isDead()) + { + mScriptEditors[script_id] = editor_handle; + return true; + } + return false; +} + +void LLScriptEditorWSServer::dissociateEditor(const std::string& script_id) +{ + mScriptEditors.erase(script_id); +} + +LLHandle LLScriptEditorWSServer::findEditorForScript(const std::string& script_id) const +{ + auto it = mScriptEditors.find(script_id); + if (it != mScriptEditors.end()) + { + return it->second; + } + return LLHandle(); +} + +//======================================================================== +void LLScriptEditorWSConnection::onOpen() +{ + +} + +void LLScriptEditorWSConnection::onClose() +{ +} + +void LLScriptEditorWSConnection::onMessage(const std::string& message) +{ + LL_DEBUGS("ScriptEditorWS") << "Received message: " << message << LL_ENDL; + + // Convert JSON string to LLSD + LLSD parsed_message; + try + { + boost::system::error_code ec; + boost::json::value json_value = boost::json::parse(message, ec); + + if (ec.failed()) + { + LL_WARNS("ScriptEditorWS") << "Failed to parse JSON message: " << ec.message() << LL_ENDL; + + // Send error response back to client + LLSD error_response; + error_response["command"] = "error"; + error_response["data"]["error_code"] = "PARSE_ERROR"; + error_response["data"]["error_message"] = "Invalid JSON format: " + std::string(ec.message()); + sendMessage(error_response); + return; + } + + // Convert boost::json::value to LLSD + parsed_message = LlsdFromJson(json_value); + + LL_DEBUGS("ScriptEditorWS") << "Parsed LLSD message type: " << parsed_message.type() + << ", has 'type' field: " << parsed_message.has("command") << LL_ENDL; + } + catch (const std::exception& e) + { + LL_WARNS("ScriptEditorWS") << "Exception parsing JSON message: " << e.what() << LL_ENDL; + + // Send error response back to client + LLSD error_response; + error_response["command"] = "error"; + error_response["data"]["error_code"] = "PARSE_EXCEPTION"; + error_response["data"]["error_message"] = "JSON parsing exception: " + std::string(e.what()); + sendMessage(error_response); + return; + } + + // Validate that we have a proper message structure + if (!parsed_message.has("command")) + { + LL_WARNS("ScriptEditorWS") << "Received message without 'type' field" << LL_ENDL; + + LLSD error_response; + error_response["command"] = "error"; + error_response["data"]["error_code"] = "INVALID_MESSAGE"; + error_response["data"]["error_message"] = "Message must have a 'type' field"; + sendMessage(error_response); + return; + } + + std::string message_type = parsed_message["command"].asString(); + LL_INFOS("ScriptEditorWS") << "Processing message of type: " << message_type << LL_ENDL; + + // Route message to appropriate handler based on type + if (message_type == "connect") + { + processConnectMessage(parsed_message); + } + else + { + LL_WARNS("ScriptEditorWS") << "Received unknown message type: " << message_type << LL_ENDL; + + LLSD error_response; + error_response["command"] = "error"; + error_response["data"]["error_code"] = "UNKNOWN_MESSAGE_TYPE"; + error_response["data"]["error_message"] = "Unknown message type: " + message_type; + sendMessage(error_response); + } +} + +void LLScriptEditorWSConnection::processConnectMessage(const LLSD& message) +{ + LL_INFOS("ScriptEditorWS") << "Processing connect message from client" << LL_ENDL; + + // Extract connection information from the message + LLSD data; + if (message.has("data")) + { + data = message["data"]; + } + + // Parse client information + std::string client_name; + std::string client_version; + std::string protocol_version; + LLSD client_capabilities; + LLSD supported_languages; + LLSD client_features; + + // Extract client identification + if (data.has("client_name")) + { + client_name = data["client_name"].asString(); + LL_INFOS("ScriptEditorWS") << "Client name: " << client_name << LL_ENDL; + } + + if (data.has("client_version")) + { + client_version = data["client_version"].asString(); + LL_INFOS("ScriptEditorWS") << "Client version: " << client_version << LL_ENDL; + } + + if (data.has("protocol_version")) + { + protocol_version = data["protocol_version"].asString(); + LL_INFOS("ScriptEditorWS") << "Protocol version: " << protocol_version << LL_ENDL; + } + + // Extract client capabilities + if (data.has("capabilities")) + { + client_capabilities = data["capabilities"]; + mEditorCapabilities = client_capabilities; // Store for later use + LL_INFOS("ScriptEditorWS") << "Client capabilities count: " << client_capabilities.size() << LL_ENDL; + } + + // Extract supported languages + if (data.has("supported_languages")) + { + supported_languages = data["supported_languages"]; + LL_INFOS("ScriptEditorWS") << "Supported languages count: " << supported_languages.size() << LL_ENDL; + } + + // Extract client features + if (data.has("features")) + { + client_features = data["features"]; + LL_INFOS("ScriptEditorWS") << "Client features available" << LL_ENDL; + } + + // Generate or extract editor session ID + if (data.has("session_id")) + { + mEditorId = data["session_id"].asString(); + LL_INFOS("ScriptEditorWS") << "Using client session ID: " << mEditorId << LL_ENDL; + } + else + { + // Generate a new session ID if client didn't provide one + mEditorId = LLUUID::generateNewID().asString(); + LL_INFOS("ScriptEditorWS") << "Generated session ID: " << mEditorId << LL_ENDL; + } + + // Validate protocol compatibility + bool protocol_compatible = true; + if (!protocol_version.empty()) + { + // For now, we only support protocol version "1.0" + if (protocol_version != "1.0") + { + protocol_compatible = false; + LL_WARNS("ScriptEditorWS") << "Unsupported protocol version: " << protocol_version + << ", expected: 1.0" << LL_ENDL; + } + } + + // Determine if we have feature compatibility + bool has_script_editing = false; + if (client_capabilities.isArray()) + { + for (LLSD::array_const_iterator it = client_capabilities.beginArray(); + it != client_capabilities.endArray(); ++it) + { + if (it->asString() == "script_editing") + { + has_script_editing = true; + break; + } + } + } + + // Build response message + LLSD response; + response["command"] = "connect_ack"; + + LLSD& response_data = response["data"]; + + if (protocol_compatible && has_script_editing) + { + // Successful connection + response_data["status"] = "connected"; + response_data["message"] = "Connection established successfully"; + response_data["session_id"] = mEditorId; + response_data["timestamp"] = LLDate::now().asString(); + + // Send back our supported capabilities that match the client's + LLSD mutual_capabilities = LLSD::emptyArray(); + + // Check which capabilities we both support + if (client_capabilities.isArray()) + { + // Our server capabilities (from onConnectionOpened) + std::set server_caps = { + "script_editing", "script_synchronization", "compilation", + "metadata", "syntax_highlighting", "error_reporting" + }; + + for (LLSD::array_const_iterator it = client_capabilities.beginArray(); + it != client_capabilities.endArray(); ++it) + { + std::string cap = it->asString(); + if (server_caps.count(cap) > 0) + { + mutual_capabilities.append(cap); + } + } + } + + response_data["mutual_capabilities"] = mutual_capabilities; + + // Send supported languages intersection + LLSD mutual_languages = LLSD::emptyArray(); + if (supported_languages.isArray()) + { + std::set server_languages = {"lsl", "luau"}; + + for (LLSD::array_const_iterator it = supported_languages.beginArray(); + it != supported_languages.endArray(); ++it) + { + std::string lang = it->asString(); + if (server_languages.count(lang) > 0) + { + mutual_languages.append(lang); + } + } + } + else + { + // Default to all our supported languages if client didn't specify + mutual_languages.append("lsl"); + mutual_languages.append("luau"); + } + + response_data["supported_languages"] = mutual_languages; + + // Connection limits and constraints + response_data["max_script_size"] = 65536; + response_data["heartbeat_interval"] = 30; + + LL_INFOS("ScriptEditorWS") << "Successfully connected client: " << client_name + << " v" << client_version + << " with " << mutual_capabilities.size() << " mutual capabilities" << LL_ENDL; + } + else + { + // Connection failed + response_data["status"] = "rejected"; + + if (!protocol_compatible) + { + response_data["error"] = "incompatible_protocol"; + response_data["message"] = "Unsupported protocol version: " + protocol_version; + } + else if (!has_script_editing) + { + response_data["error"] = "missing_capabilities"; + response_data["message"] = "Client must support 'script_editing' capability"; + } + else + { + response_data["error"] = "connection_failed"; + response_data["message"] = "Connection failed for unknown reason"; + } + + LL_WARNS("ScriptEditorWS") << "Rejected connection from client: " << client_name + << " - " << response_data["message"].asString() << LL_ENDL; + } + + // Send the response back to the client + if (sendMessage(response)) + { + LL_INFOS("ScriptEditorWS") << "Sent connect acknowledgment to client" << LL_ENDL; + } + else + { + LL_WARNS("ScriptEditorWS") << "Failed to send connect acknowledgment to client" << LL_ENDL; + } + + // If connection was successful, we could also send any initial state or configuration + if (response_data["status"].asString() == "connected") + { + // TODO: Send initial script list, active editors, or other relevant state + // Example: sendScriptList(), sendActiveEditors(), etc. + } +} -- cgit v1.3 From f31c194b8674df295edf74693a2f843ca314ca92 Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Tue, 26 Aug 2025 21:29:41 -0700 Subject: Expand the websocket implementation a bit. Added JSONRPC specialization. --- indra/llcorehttp/CMakeLists.txt | 2 + indra/llcorehttp/lljsonrpcws.cpp | 613 +++++++++++++++++++++++++++++++ indra/llcorehttp/lljsonrpcws.h | 461 ++++++++++++++++++++++++ indra/llcorehttp/llwebsocketmgr.cpp | 35 +- indra/llcorehttp/llwebsocketmgr.h | 10 +- indra/newview/llappviewer.cpp | 6 + indra/newview/llpreviewscript.cpp | 71 ++-- indra/newview/llpreviewscript.h | 17 +- indra/newview/llscripteditorws.cpp | 696 +++++++++++++----------------------- indra/newview/llscripteditorws.h | 156 +++++--- 10 files changed, 1523 insertions(+), 544 deletions(-) create mode 100644 indra/llcorehttp/lljsonrpcws.cpp create mode 100644 indra/llcorehttp/lljsonrpcws.h (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt index d8d5c577d5..fa37d23126 100644 --- a/indra/llcorehttp/CMakeLists.txt +++ b/indra/llcorehttp/CMakeLists.txt @@ -25,6 +25,7 @@ set(llcorehttp_SOURCE_FILES httpresponse.cpp httpstats.cpp llwebsocketmgr.cpp + lljsonrpcws.cpp _httplibcurl.cpp _httpopcancel.cpp _httpoperation.cpp @@ -54,6 +55,7 @@ set(llcorehttp_HEADER_FILES httpresponse.h httpstats.h llwebsocketmgr.h + lljsonrpcws.h _httpinternal.h _httplibcurl.h _httpopcancel.h diff --git a/indra/llcorehttp/lljsonrpcws.cpp b/indra/llcorehttp/lljsonrpcws.cpp new file mode 100644 index 0000000000..5de595c595 --- /dev/null +++ b/indra/llcorehttp/lljsonrpcws.cpp @@ -0,0 +1,613 @@ +/** + * @file lljsonrpcws.cpp + * @brief JSON-RPC 2.0 WebSocket server and connection implementation + * + * $LicenseInfo:firstyear=2025&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2025, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#include "linden_common.h" + +#include "lljsonrpcws.h" +#include "llerror.h" +#include "llsdjson.h" +#include "lldate.h" + +#include + +//======================================================================== +// LLJSONRPCConnection Implementation +//======================================================================== + +void LLJSONRPCConnection::onOpen() +{ + LL_INFOS("JSONRPC") << "JSON-RPC connection opened" << LL_ENDL; +} + +void LLJSONRPCConnection::onClose() +{ + LL_INFOS("JSONRPC") << "JSON-RPC connection closed, clearing " + << mPendingRequests.size() << " pending requests" << LL_ENDL; + + // Cancel all pending requests + for (auto& [id, callback] : mPendingRequests) + { + if (callback) + { + LLSD error; + error["code"] = RPCError::CONNECTION_CLOSED; // Use named constant instead of magic number + error["message"] = "Connection closed"; + callback(LLSD(), error); + } + } + mPendingRequests.clear(); +} + +void LLJSONRPCConnection::onMessage(const std::string& message) +{ + LL_DEBUGS("JSONRPC") << "Received JSON-RPC message: " << message << LL_ENDL; + + try + { + // Parse JSON message + boost::system::error_code ec; + boost::json::value json_value = boost::json::parse(message, ec); + + if (ec.failed()) + { + LL_WARNS("JSONRPC") << "Failed to parse JSON: " << ec.message() << LL_ENDL; + sendError(LLSD(), ParseError(ec.message())); + return; + } + + // Convert to LLSD + LLSD message_obj = LlsdFromJson(json_value); + + // Handle batch vs single message + if (message_obj.isArray()) + { + // Batch request + if (message_obj.size() == 0) + { + sendError(LLSD(), InvalidRequest("Empty batch")); + return; + } + + // Process each message in the batch + for (S32 i = 0; i < message_obj.size(); ++i) + { + processMessage(message_obj[i]); + } + } + else + { + // Single message + processMessage(message_obj); + } + } + catch (const std::exception& e) + { + LL_WARNS("JSONRPC") << "Exception processing JSON-RPC message: " << e.what() << LL_ENDL; + sendError(LLSD(), InternalError(e.what())); + } +} + +void LLJSONRPCConnection::processMessage(const LLSD& message_obj) +{ + try + { + // Determine if this is a request, notification, or response + if (message_obj.has("method")) + { + // This is a request or notification + validateMessage(message_obj, true); + processRequest(message_obj); + } + else if (message_obj.has("result") || message_obj.has("error")) + { + // This is a response + validateMessage(message_obj, false); + processResponse(message_obj); + } + else + { + throw InvalidRequest("Message must contain 'method' or 'result'/'error'"); + } + } + catch (const RPCError& e) + { + LLSD id = message_obj.has("id") ? message_obj["id"] : LLSD(); + sendError(id, e); + } +} + +void LLJSONRPCConnection::processRequest(const LLSD& request) +{ + std::string method = request["method"].asString(); + LLSD params = request.has("params") ? request["params"] : LLSD(); + LLSD id = request.has("id") ? request["id"] : LLSD(); + bool is_notification = !request.has("id"); + + LL_DEBUGS("JSONRPC") << "Processing " << (is_notification ? "notification" : "request") + << " for method: " << method << LL_ENDL; + + // Find method handler + auto it = mMethodHandlers.find(method); + if (it == mMethodHandlers.end()) + { + if (!is_notification) + { + sendError(id, MethodNotFound(method)); + } + return; + } + + try + { + // Call the method handler with method name, ID, and parameters + LLSD result = it->second(method, id, params); + + // Send response (only for requests, not notifications) + if (!is_notification) + { + sendResponse(id, result); + } + } + catch (const RPCError& e) + { + if (!is_notification) + { + sendError(id, e); + } + else + { + LL_WARNS("JSONRPC") << "Error in notification handler for " << method + << ": " << e.what() << LL_ENDL; + } + } + catch (const std::exception& e) + { + if (!is_notification) + { + sendError(id, InternalError(e.what())); + } + else + { + LL_WARNS("JSONRPC") << "Exception in notification handler for " << method + << ": " << e.what() << LL_ENDL; + } + } +} + +void LLJSONRPCConnection::processResponse(const LLSD& response) +{ + if (!response.has("id")) + { + LL_WARNS("JSONRPC") << "Response missing id field" << LL_ENDL; + return; + } + + std::string id = response["id"].asString(); + auto it = mPendingRequests.find(id); + if (it == mPendingRequests.end()) + { + LL_WARNS("JSONRPC") << "Received response for unknown request id: " << id << LL_ENDL; + return; + } + + ResponseCallback callback = it->second; + mPendingRequests.erase(it); + + if (callback) + { + LLSD result = response.has("result") ? response["result"] : LLSD(); + LLSD error = response.has("error") ? response["error"] : LLSD(); + + callback(result, error); + } +} + +void LLJSONRPCConnection::validateMessage(const LLSD& message, bool is_request) +{ + // Check JSON-RPC version + if (!message.has("jsonrpc") || message["jsonrpc"].asString() != "2.0") + { + throw InvalidRequest("Missing or invalid jsonrpc version"); + } + + if (is_request) + { + // Request/notification validation + if (!message.has("method")) + { + throw InvalidRequest("Missing method field"); + } + + if (!message["method"].isString()) + { + throw InvalidRequest("Method must be a string"); + } + + // Params are optional but must be array or object if present + if (message.has("params")) + { + if (!message["params"].isArray() && !message["params"].isMap()) + { + throw InvalidParams("Params must be array or object"); + } + } + } + else + { + // Response validation + if (!message.has("id")) + { + throw InvalidRequest("Response missing id field"); + } + + // Must have either result or error, but not both + bool has_result = message.has("result"); + bool has_error = message.has("error"); + + if (!has_result && !has_error) + { + throw InvalidRequest("Response must have result or error"); + } + + if (has_result && has_error) + { + throw InvalidRequest("Response cannot have both result and error"); + } + + // Error must be an object with code and message + if (has_error) + { + LLSD error = message["error"]; + if (!error.isMap()) + { + throw InvalidRequest("Error must be an object"); + } + if (!error.has("code") || !error.has("message")) + { + throw InvalidRequest("Error must have code and message"); + } + } + } +} + +LLSD LLJSONRPCConnection::generateId() +{ + // Server-wide atomic counter for efficient unique ID generation + // Start from 1000 to avoid conflicts with any manual test IDs + static std::atomic sRequestIdCounter{1000}; + + // Generate server-unique sequential ID + U64 id = sRequestIdCounter.fetch_add(1); + return LLSD(llformat("rpc_%llu", id)); +} + +void LLJSONRPCConnection::registerMethod(const std::string& method, MethodHandler handler) +{ + mMethodHandlers[method] = handler; + LL_INFOS("JSONRPC") << "Registered method: " << method << LL_ENDL; +} + +void LLJSONRPCConnection::unregisterMethod(const std::string& method) +{ + mMethodHandlers.erase(method); + LL_INFOS("JSONRPC") << "Unregistered method: " << method << LL_ENDL; +} + +LLSD LLJSONRPCConnection::call(const std::string& method, const LLSD& params, ResponseCallback callback) +{ + LLSD request; + request["jsonrpc"] = "2.0"; + request["method"] = method; + + if (!params.isUndefined()) + { + request["params"] = params; + } + + LLSD id = generateId(); + request["id"] = id; + + // Store callback if provided + if (callback) + { + mPendingRequests[id.asString()] = callback; + } + + // Send the request + if (!sendMessage(LlsdToJson(request))) + { + // Remove from pending if send failed + if (callback) + { + mPendingRequests.erase(id.asString()); + } + throw InternalError("Failed to send request"); + } + + LL_DEBUGS("JSONRPC") << "Sent request: " << method << " with id: " << id.asString() << LL_ENDL; + return id; +} + +void LLJSONRPCConnection::notify(const std::string& method, const LLSD& params) +{ + LLSD notification; + notification["jsonrpc"] = "2.0"; + notification["method"] = method; + + if (!params.isUndefined()) + { + notification["params"] = params; + } + + // Notifications don't have an id + + if (!sendMessage(LlsdToJson(notification))) + { + throw InternalError("Failed to send notification"); + } + + LL_DEBUGS("JSONRPC") << "Sent notification: " << method << LL_ENDL; +} + +void LLJSONRPCConnection::sendResponse(const LLSD& id, const LLSD& result) +{ + LLSD response; + response["jsonrpc"] = "2.0"; + response["result"] = result; + response["id"] = id; + + if (!sendMessage(LlsdToJson(response))) + { + LL_WARNS("JSONRPC") << "Failed to send response for id: " << id.asString() << LL_ENDL; + } + else + { + LL_DEBUGS("JSONRPC") << "Sent response for id: " << id.asString() << LL_ENDL; + } +} + +void LLJSONRPCConnection::sendError(const LLSD& id, const RPCError& error) +{ + LLSD response; + response["jsonrpc"] = "2.0"; + + LLSD error_obj; + error_obj["code"] = error.getCode(); + error_obj["message"] = error.what(); + + if (!error.getData().isUndefined()) + { + error_obj["data"] = error.getData(); + } + + response["error"] = error_obj; + response["id"] = id.isUndefined() ? LLSD() : id; // null for parse errors + + if (!sendMessage(LlsdToJson(response))) + { + LL_WARNS("JSONRPC") << "Failed to send error response" << LL_ENDL; + } + else + { + LL_DEBUGS("JSONRPC") << "Sent error response: " << error.what() << LL_ENDL; + } +} + +void LLJSONRPCConnection::sendBatch(const LLSD& batch, ResponseCallback callback) +{ + if (!batch.isArray() || batch.size() == 0) + { + throw InvalidRequest("Batch must be non-empty array"); + } + + // For batch requests with callbacks, we need to track multiple responses + // This is complex as we need to correlate all responses before calling callback + // For now, we'll send the batch but won't support batch response callbacks + if (callback) + { + LL_WARNS("JSONRPC") << "Batch response callbacks not yet implemented" << LL_ENDL; + } + + if (!sendMessage(LlsdToJson(batch))) + { + throw InternalError("Failed to send batch"); + } + + LL_DEBUGS("JSONRPC") << "Sent batch with " << batch.size() << " messages" << LL_ENDL; +} + +//======================================================================== +// LLJSONRPCServer Implementation +//======================================================================== + +LLJSONRPCServer::LLJSONRPCServer(const std::string& name, U16 port, bool local_only) + : LLWebsocketMgr::WSServer(name, port, local_only), mServerName(name) +{ + LL_INFOS("JSONRPC") << "Created JSON-RPC server: " << name + << " on port " << port << LL_ENDL; + + // Register standard JSON-RPC methods + registerGlobalMethod("system.listMethods", [this](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + LL_DEBUGS("JSONRPC") << "System method " << method << " called" << LL_ENDL; + return getMethodList(); + }); + + registerGlobalMethod("system.getStats", [this](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + LL_DEBUGS("JSONRPC") << "System method " << method << " called" << LL_ENDL; + return getServerStats(); + }); + + registerGlobalMethod("system.ping", [](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + LL_DEBUGS("JSONRPC") << "System method " << method << " called" << LL_ENDL; + LLSD result; + result["pong"] = LLDate::now().asString(); + result["params"] = params; + return result; + }); +} + +LLWebsocketMgr::WSConnection::ptr_t LLJSONRPCServer::connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, + LLWebsocketMgr::connection_h handle) +{ + auto connection = std::make_shared(server, handle); + setupConnectionMethods(connection); + return connection; +} + +void LLJSONRPCServer::onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) +{ + LL_INFOS("JSONRPC") << "JSON-RPC client connected, total connections: " + << getConnectionCount() << LL_ENDL; +} + +void LLJSONRPCServer::onConnectionClosed(const LLWebsocketMgr::WSConnection::ptr_t& connection) +{ + LL_INFOS("JSONRPC") << "JSON-RPC client disconnected, total connections: " + << getConnectionCount() << LL_ENDL; +} + +void LLJSONRPCServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) +{ + LLMutexLock lock(&mGlobalMethodsMutex); + + // Register all global methods on the new connection + for (const auto& [method, handler] : mGlobalMethods) + { + connection->registerMethod(method, handler); + } +} + +void LLJSONRPCServer::registerGlobalMethod(const std::string& method, MethodHandler handler) +{ + { + LLMutexLock lock(&mGlobalMethodsMutex); + mGlobalMethods[method] = handler; + } + + // Apply to all existing connections - we need to iterate through connections + // Since mConnections is private, we need to use broadcastMessage or find another approach + // For now, we'll only apply to new connections + + LL_INFOS("JSONRPC") << "Registered global method: " << method << LL_ENDL; +} + +void LLJSONRPCServer::unregisterGlobalMethod(const std::string& method) +{ + { + LLMutexLock lock(&mGlobalMethodsMutex); + mGlobalMethods.erase(method); + } + + // For existing connections, we would need access to them + // This is a limitation of the current design - methods added after connection + // establishment won't be retroactively applied + + LL_INFOS("JSONRPC") << "Unregistered global method: " << method << LL_ENDL; +} + +LLSD LLJSONRPCServer::getMethodList() const +{ + LLMutexLock lock(&mGlobalMethodsMutex); + + LLSD methods = LLSD::emptyArray(); + for (const auto& [method, handler] : mGlobalMethods) + { + methods.append(method); + } + + return methods; +} + +void LLJSONRPCServer::broadcastNotification(const std::string& method, const LLSD& params) +{ + // Use custom broadcast logic since we need to call notify() on each JSON-RPC connection + // We can't use the base broadcastMessage() because we need structured JSON-RPC messages + + // Create the notification message + LLSD notification; + notification["jsonrpc"] = "2.0"; + notification["method"] = method; + if (!params.isUndefined()) + { + notification["params"] = params; + } + + // Use the base class broadcast functionality + broadcastMessage(boost::json::serialize(LlsdToJson(notification))); + + mTotalNotificationsSent += getConnectionCount(); + LL_DEBUGS("JSONRPC") << "Broadcast notification: " << method + << " to " << getConnectionCount() << " clients" << LL_ENDL; +} + +void LLJSONRPCServer::broadcastCall(const std::string& method, const LLSD& params, + BatchResponseCallback callback) +{ + if (callback) + { + LL_WARNS("JSONRPC") << "Broadcast call response callbacks not yet implemented" << LL_ENDL; + } + + // Create the request message with a server-unique ID + LLSD request; + request["jsonrpc"] = "2.0"; + request["method"] = method; + + // Use the same ID generation as connections for consistency + static std::atomic sBroadcastIdCounter{10000000}; // Start at 10M to clearly distinguish from regular requests + U64 id = sBroadcastIdCounter.fetch_add(1); + request["id"] = LLSD(llformat("broadcast_%llu", id)); + + if (!params.isUndefined()) + { + request["params"] = params; + } + + // Use the base class broadcast functionality + broadcastMessage(boost::json::serialize(LlsdToJson(request))); + + LL_DEBUGS("JSONRPC") << "Broadcast call: " << method + << " to " << getConnectionCount() << " clients" << LL_ENDL; +} + +LLSD LLJSONRPCServer::getServerStats() const +{ + LLSD stats; + stats["server_name"] = mServerName; + stats["connection_count"] = static_cast(getConnectionCount()); + stats["is_running"] = isRunning(); + + { + LLMutexLock lock(&mGlobalMethodsMutex); + stats["global_method_count"] = static_cast(mGlobalMethods.size()); + } + + stats["total_requests_handled"] = static_cast(mTotalRequestsHandled.load()); + stats["total_notifications_sent"] = static_cast(mTotalNotificationsSent.load()); + stats["uptime"] = LLDate::now().asString(); + + return stats; +} diff --git a/indra/llcorehttp/lljsonrpcws.h b/indra/llcorehttp/lljsonrpcws.h new file mode 100644 index 0000000000..54578c0e93 --- /dev/null +++ b/indra/llcorehttp/lljsonrpcws.h @@ -0,0 +1,461 @@ +/** + * @file lljsonrpcws.h + * @brief JSON-RPC 2.0 WebSocket server and connection implementation + * + * $LicenseInfo:firstyear=2025&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2025, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#pragma once + +#include "llwebsocketmgr.h" +#include "llsd.h" +#include "lluuid.h" + +#include +#include +#include + +/** + * @class LLJSONRPCConnection + * @brief JSON-RPC 2.0 WebSocket connection implementation + * + * This class implements the JSON-RPC 2.0 protocol over WebSocket connections. + * It handles request/response patterns, notifications, method registration, + * and error handling according to the JSON-RPC 2.0 specification. + * + * ## JSON-RPC 2.0 Protocol Features + * + * - **Requests**: Method calls that expect a response + * - **Notifications**: Method calls that do not expect a response + * - **Batch Operations**: Multiple requests/notifications in a single message + * - **Error Handling**: Standardized error codes and messages + * - **ID Correlation**: Request/response correlation using unique identifiers + * + * ## Method Handler Registration + * + * Methods use an enhanced handler signature that provides method name and request ID context: + * + * @code + * connection->registerMethod("echo", [](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + * LL_INFOS("JSONRPC") << "Method " << method << " called with ID " << id.asString() << LL_ENDL; + * return params; // Echo back the parameters + * }); + * + * connection->registerMethod("add", [](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + * if (params.isArray() && params.size() >= 2) { + * LL_INFOS("JSONRPC") << "Adding numbers via " << method << LL_ENDL; + * return params[0].asReal() + params[1].asReal(); + * } + * throw LLJSONRPCConnection::InvalidParams("Expected array with 2 numbers"); + * }); + * @endcode + * + * The enhanced signature enables: + * - Method context awareness for shared handlers + * - Request correlation and distributed tracing + * - Distinction between notifications (id undefined) and requests + * - Enhanced logging and error reporting with context + * + * ## Making RPC Calls + * + * @code + * // Asynchronous request with callback + * LLSD params; + * params.append(5); + * params.append(3); + * connection->call("add", params, [](const LLSD& result, const LLSD& error) { + * if (error.isUndefined()) { + * LL_INFOS() << "Result: " << result.asReal() << LL_ENDL; + * } else { + * LL_WARNS() << "Error: " << error["message"].asString() << LL_ENDL; + * } + * }); + * + * // Fire-and-forget notification + * connection->notify("log", LLSD("Server started")); + * @endcode + */ +class LLJSONRPCConnection : public LLWebsocketMgr::WSConnection +{ +public: + using ptr_t = std::shared_ptr; + + /// Method handler function signature + /// @param method The method name that was called + /// @param id The request ID (undefined for notifications) + /// @param params The parameters passed to the method + /// @return The result to return to the caller + /// @throw RPCError-derived exceptions for error responses + using MethodHandler = std::function; + + /// Response callback function signature + /// @param result The result from a successful call (undefined if error occurred) + /// @param error The error object if call failed (undefined if successful) + using ResponseCallback = std::function; + + /** + * @brief JSON-RPC error base class + */ + class RPCError : public std::runtime_error + { + public: + // JSON-RPC 2.0 Standard Error Codes + static constexpr S32 PARSE_ERROR = -32700; ///< Invalid JSON was received by the server + static constexpr S32 INVALID_REQUEST = -32600; ///< The JSON sent is not a valid Request object + static constexpr S32 METHOD_NOT_FOUND = -32601; ///< The method does not exist / is not available + static constexpr S32 INVALID_PARAMS = -32602; ///< Invalid method parameter(s) + static constexpr S32 INTERNAL_ERROR = -32603; ///< Internal JSON-RPC error + + // Server Error Range (-32000 to -32099) + static constexpr S32 SERVER_ERROR_MIN = -32099; ///< Server error range minimum + static constexpr S32 SERVER_ERROR_MAX = -32000; ///< Server error range maximum + + // Common server-specific errors + static constexpr S32 CONNECTION_CLOSED = -32000; ///< Connection closed unexpectedly + static constexpr S32 REQUEST_TIMEOUT = -32001; ///< Request timed out + static constexpr S32 UNAUTHORIZED = -32002; ///< Authentication required + static constexpr S32 FORBIDDEN = -32003; ///< Access denied + static constexpr S32 RATE_LIMITED = -32004; ///< Too many requests + static constexpr S32 SERVICE_UNAVAILABLE = -32005; ///< Service temporarily unavailable + static constexpr S32 MESSAGE_TOO_LARGE = -32006; ///< Message exceeds maximum size + static constexpr S32 INVALID_SESSION = -32007; ///< Session expired or invalid + + RPCError(S32 code, const std::string& message, const LLSD& data = LLSD()) + : std::runtime_error(message), mCode(code), mData(data) {} + + S32 getCode() const { return mCode; } + const LLSD& getData() const { return mData; } + + protected: + S32 mCode; + LLSD mData; + }; + + /// Standard JSON-RPC error classes using named constants + class ParseError : public RPCError { + public: + ParseError(const std::string& details = "") + : RPCError(PARSE_ERROR, "Parse error" + (details.empty() ? "" : ": " + details)) {} + }; + + class InvalidRequest : public RPCError { + public: + InvalidRequest(const std::string& details = "") + : RPCError(INVALID_REQUEST, "Invalid Request" + (details.empty() ? "" : ": " + details)) {} + }; + + class MethodNotFound : public RPCError { + public: + MethodNotFound(const std::string& method = "") + : RPCError(METHOD_NOT_FOUND, "Method not found" + (method.empty() ? "" : ": " + method)) {} + }; + + class InvalidParams : public RPCError { + public: + InvalidParams(const std::string& details = "") + : RPCError(INVALID_PARAMS, "Invalid params" + (details.empty() ? "" : ": " + details)) {} + }; + + class InternalError : public RPCError { + public: + InternalError(const std::string& details = "") + : RPCError(INTERNAL_ERROR, "Internal error" + (details.empty() ? "" : ": " + details)) {} + }; + + /// Server-specific errors (in the -32000 to -32099 range) + class ConnectionClosedError : public RPCError { + public: + ConnectionClosedError(const std::string& details = "Connection closed") + : RPCError(CONNECTION_CLOSED, details) {} + }; + + class RequestTimeoutError : public RPCError { + public: + RequestTimeoutError(const std::string& details = "Request timed out") + : RPCError(REQUEST_TIMEOUT, details) {} + }; + + class UnauthorizedError : public RPCError { + public: + UnauthorizedError(const std::string& details = "Authentication required") + : RPCError(UNAUTHORIZED, details) {} + }; + + class ForbiddenError : public RPCError { + public: + ForbiddenError(const std::string& details = "Access denied") + : RPCError(FORBIDDEN, details) {} + }; + + class RateLimitedError : public RPCError { + public: + RateLimitedError(const std::string& details = "Too many requests") + : RPCError(RATE_LIMITED, details) {} + }; + + class ServiceUnavailableError : public RPCError { + public: + ServiceUnavailableError(const std::string& details = "Service temporarily unavailable") + : RPCError(SERVICE_UNAVAILABLE, details) {} + }; + + class MessageTooLargeError : public RPCError { + public: + MessageTooLargeError(const std::string& details = "Message exceeds maximum size") + : RPCError(MESSAGE_TOO_LARGE, details) {} + }; + + class InvalidSessionError : public RPCError { + public: + InvalidSessionError(const std::string& details = "Session expired or invalid") + : RPCError(INVALID_SESSION, details) {} + }; + + LLJSONRPCConnection(const LLWebsocketMgr::WSServer::ptr_t server, + const LLWebsocketMgr::connection_h& handle) + : LLWebsocketMgr::WSConnection(server, handle) {} + + virtual ~LLJSONRPCConnection() = default; + + // WebSocket connection lifecycle + void onOpen() override; + void onClose() override; + void onMessage(const std::string& message) override; + + /** + * @brief Register a method handler + * @param method The method name to register + * @param handler The function to call when this method is invoked + */ + void registerMethod(const std::string& method, MethodHandler handler); + + /** + * @brief Unregister a method handler + * @param method The method name to unregister + */ + void unregisterMethod(const std::string& method); + + /** + * @brief Make an asynchronous JSON-RPC call + * @param method The method name to call + * @param params The parameters to pass + * @param callback Callback for the response (optional) + * @return The request ID for correlation + */ + LLSD call(const std::string& method, const LLSD& params = LLSD(), + ResponseCallback callback = nullptr); + + /** + * @brief Send a JSON-RPC notification (no response expected) + * @param method The method name + * @param params The parameters to pass + */ + void notify(const std::string& method, const LLSD& params = LLSD()); + + /** + * @brief Send a successful response to a request + * @param id The request ID from the original request + * @param result The result to return + */ + void sendResponse(const LLSD& id, const LLSD& result); + + /** + * @brief Send an error response to a request + * @param id The request ID from the original request (can be null) + * @param error The RPCError to send + */ + void sendError(const LLSD& id, const RPCError& error); + + /** + * @brief Send a batch of requests/notifications + * @param batch Array of request/notification objects + * @param callback Callback for batch response (optional) + */ + void sendBatch(const LLSD& batch, ResponseCallback callback = nullptr); + +protected: + /** + * @brief Process a single JSON-RPC message + * @param message_obj The parsed JSON message + */ + void processMessage(const LLSD& message_obj); + + /** + * @brief Process a JSON-RPC request + * @param request The request object + */ + void processRequest(const LLSD& request); + + /** + * @brief Process a JSON-RPC response + * @param response The response object + */ + void processResponse(const LLSD& response); + + /** + * @brief Validate a JSON-RPC message structure + * @param message The message to validate + * @param is_request True if validating a request, false for response + * @throw InvalidRequest if validation fails + */ + void validateMessage(const LLSD& message, bool is_request = true); + + /** + * @brief Generate the next unique request ID + * @return A server-unique request ID + * + * Generates a server-wide unique identifier using an atomic counter. + * This ensures request IDs are unique across all connections within the + * server instance, providing efficient ID generation with guaranteed uniqueness. + * + * IDs follow the format "rpc_{counter}" where counter is a monotonically + * increasing 64-bit value starting from 1. This approach provides: + * - Guaranteed uniqueness within server scope + * - High performance (atomic increment operation) + * - Predictable, sequential ordering for debugging + * - Thread-safe generation across multiple connections + */ + LLSD generateId(); + +private: + std::unordered_map mMethodHandlers; + std::unordered_map mPendingRequests; +}; + +/** + * @class LLJSONRPCServer + * @brief JSON-RPC 2.0 WebSocket server implementation + * + * This server extends the basic WebSocket server to provide JSON-RPC 2.0 + * protocol support. It manages JSON-RPC connections and provides server-wide + * method registration and broadcasting capabilities. + * + * ## Server-Wide Method Registration + * + * Methods can be registered at the server level and will be available + * on all connections: + * + * @code + * auto server = std::make_shared("rpc_server", 8080); + * + * server->registerGlobalMethod("getServerInfo", [](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + * LL_INFOS("JSONRPC") << "Server info requested via " << method << LL_ENDL; + * LLSD info; + * info["name"] = "My RPC Server"; + * info["version"] = "1.0.0"; + * info["uptime"] = LLDate::now().secondsSinceEpoch(); + * return info; + * }); + * + * server->registerGlobalMethod("listMethods", [server](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD { + * return server->getMethodList(); + * }); + * @endcode + * + * ## Broadcasting and Multi-client Operations + * + * @code + * // Broadcast notification to all connected clients + * server->broadcastNotification("serverAlert", LLSD("Server will restart in 5 minutes")); + * + * // Call a method on all clients and collect responses + * server->broadcastCall("getClientStatus", LLSD(), [](const LLSD& responses) { + * for (const auto& response : llsd::inArray(responses)) { + * LL_INFOS() << "Client status: " << response << LL_ENDL; + * } + * }); + * @endcode + */ +class LLJSONRPCServer : public LLWebsocketMgr::WSServer +{ +public: + using ptr_t = std::shared_ptr; + using MethodHandler = LLJSONRPCConnection::MethodHandler; + using ResponseCallback = LLJSONRPCConnection::ResponseCallback; + using BatchResponseCallback = std::function; + + LLJSONRPCServer(const std::string& name, U16 port, bool local_only = true); + virtual ~LLJSONRPCServer() = default; + + // Server lifecycle callbacks + void onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) override; + void onConnectionClosed(const LLWebsocketMgr::WSConnection::ptr_t& connection) override; + + /** + * @brief Register a global method available on all connections + * @param method The method name to register + * @param handler The function to call when this method is invoked + */ + void registerGlobalMethod(const std::string& method, MethodHandler handler); + + /** + * @brief Unregister a global method + * @param method The method name to unregister + */ + void unregisterGlobalMethod(const std::string& method); + + /** + * @brief Get list of registered global methods + * @return Array of method names + */ + LLSD getMethodList() const; + + /** + * @brief Broadcast a notification to all connected clients + * @param method The method name + * @param params The parameters to pass + */ + void broadcastNotification(const std::string& method, const LLSD& params = LLSD()); + + /** + * @brief Call a method on all connected clients + * @param method The method name + * @param params The parameters to pass + * @param callback Callback to receive aggregated responses + */ + void broadcastCall(const std::string& method, const LLSD& params = LLSD(), + BatchResponseCallback callback = nullptr); + + /** + * @brief Get server statistics + * @return Statistics object with connection count, method count, etc. + */ + LLSD getServerStats() const; + +protected: + LLWebsocketMgr::WSConnection::ptr_t connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, + LLWebsocketMgr::connection_h handle) override; + + /** + * @brief Apply global method handlers to a new connection + * @param connection The connection to configure + */ + virtual void setupConnectionMethods(LLJSONRPCConnection::ptr_t connection); + +private: + std::unordered_map mGlobalMethods; + mutable LLMutex mGlobalMethodsMutex; + + std::string mServerName; // Store server name for stats + std::atomic mTotalRequestsHandled{0}; + std::atomic mTotalNotificationsSent{0}; +}; diff --git a/indra/llcorehttp/llwebsocketmgr.cpp b/indra/llcorehttp/llwebsocketmgr.cpp index 3e4262b49b..d44d5d877d 100644 --- a/indra/llcorehttp/llwebsocketmgr.cpp +++ b/indra/llcorehttp/llwebsocketmgr.cpp @@ -63,6 +63,32 @@ void LLWebsocketMgr::cleanupSingleton() stopAllServers(); } +void LLWebsocketMgr::update() +{ + std::vector stops; + + for (auto &[name, server] : mServers) + { + if (server && server->isRunning()) + { + if (!server->update()) + { + stops.push_back(server); + } + } + } + + for (const auto& server : stops) + { + if (server) + { + LL_DEBUGS("WebSocket") << "Stopping server: " << server->mServerName << LL_ENDL; + removeServer(server->mServerName); + } + } +} + + LLWebsocketMgr::WSServer::ptr_t LLWebsocketMgr::findServerByName(const std::string &name) const { auto it = mServers.find(std::string(name)); @@ -192,6 +218,7 @@ struct Server_impl mPort(port), mLocalOnly(local_only) { + mServer.set_open_handler([this](websocketpp::connection_hdl hdl) { this->onOpen(hdl); }); mServer.set_close_handler([this](websocketpp::connection_hdl hdl) { this->onClose(hdl); }); mServer.set_message_handler([this](websocketpp::connection_hdl hdl, Server_t::message_ptr msg) { this->onMessage(hdl, msg); }); @@ -647,12 +674,12 @@ void LLWebsocketMgr::WSServer::handleMessage(const connection_h& handle, const s //------------------------------------------------------------------------ bool LLWebsocketMgr::WSConnection::sendMessage(const std::string& message) const { - if (!mServer) + if (mOwningServer.expired()) { LL_WARNS("WebSocket") << "Attempted to send message on connection with null server reference" << LL_ENDL; return false; } - return mServer->sendMessageTo(mConnectionHandle, message); + return mOwningServer.lock()->sendMessageTo(mConnectionHandle, message); } bool LLWebsocketMgr::WSConnection::sendMessage(const boost::json::value& json) const @@ -668,7 +695,7 @@ bool LLWebsocketMgr::WSConnection::sendMessage(const LLSD& data) const void LLWebsocketMgr::WSConnection::closeConnection(U16 code, const std::string& reason) { - if (!mServer) + if (mOwningServer.expired()) { LL_WARNS("WebSocket") << "Attempted to close connection with null server reference" << LL_ENDL; return; @@ -677,7 +704,7 @@ void LLWebsocketMgr::WSConnection::closeConnection(U16 code, const std::string& LL_INFOS("WebSocket") << "WSConnection closing connection with code " << code << " and reason: " << (reason.empty() ? "(no reason)" : reason) << LL_ENDL; - if (!mServer->closeConnection(mConnectionHandle, code, reason)) + if (!mOwningServer.lock()->closeConnection(mConnectionHandle, code, reason)) { LL_WARNS("WebSocket") << "Failed to close connection through server" << LL_ENDL; } diff --git a/indra/llcorehttp/llwebsocketmgr.h b/indra/llcorehttp/llwebsocketmgr.h index 08f6f22dbc..570c8ad6cd 100644 --- a/indra/llcorehttp/llwebsocketmgr.h +++ b/indra/llcorehttp/llwebsocketmgr.h @@ -78,7 +78,7 @@ public: */ WSConnection(const std::shared_ptr &server, const connection_h& handle): mConnectionHandle(handle), - mServer(server) + mOwningServer(server) {} virtual ~WSConnection() = default; @@ -188,9 +188,9 @@ public: */ void closeConnection(U16 code = 1000, const std::string& reason = std::string()); - private: + protected: connection_h mConnectionHandle; - std::shared_ptr mServer; // Back-reference to the server this connection belongs to + std::weak_ptr mOwningServer; // Back-reference to the server this connection belongs to }; /** @@ -271,6 +271,8 @@ public: } void broadcastMessage(const std::string& message); + virtual bool update() { return true; } + protected: virtual WSConnection::ptr_t connectionFactory(WSServer::ptr_t server, connection_h handle); @@ -320,6 +322,8 @@ public: bool startServer(const std::string &name) const; void stopServer(const std::string &name) const; + void update(); + protected: void initSingleton() override; void cleanupSingleton() override; diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp index 63d364eaa8..6540517ef2 100644 --- a/indra/newview/llappviewer.cpp +++ b/indra/newview/llappviewer.cpp @@ -109,6 +109,7 @@ #include "lllocalbitmaps.h" #include "llperfstats.h" #include "llgltfmateriallist.h" +#include "llwebsocketmgr.h" // Linden library includes #include "llavatarnamecache.h" @@ -4754,6 +4755,11 @@ void LLAppViewer::idle() LLMortician::updateClass(); LLFilePickerThread::clearDead(); //calls LLFilePickerThread::notify() LLDirPickerThread::clearDead(); + + if (LLWebsocketMgr::instanceExists()) + { + LLWebsocketMgr::instance().update(); + } F32 dt_raw = idle_timer.getElapsedTimeAndResetF32(); LLGLTFMaterialList::flushUpdates(); diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp index 9b2a149212..3ab2e747ea 100644 --- a/indra/newview/llpreviewscript.cpp +++ b/indra/newview/llpreviewscript.cpp @@ -1144,28 +1144,7 @@ void LLScriptEdCore::openInExternalEditor() // Start watching file changes. mContainer->mLiveFile = new LLLiveLSLFile(filename, boost::bind(&LLScriptEdContainer::onExternalChange, mContainer, _1)); mContainer->mLiveFile->addToEventTimer(); - - // if the user has enabled websockets, create the server to talk to the external editor - { - // TODO: Get the name, port, and locality from settings - std::string server_name(LLScriptEditorWSServer::DEFAULT_SERVER_NAME); - U16 server_port(LLScriptEditorWSServer::DEFAULT_SERVER_PORT); - bool server_localhost(true); - - LLWebsocketMgr& wsmgr = LLWebsocketMgr::instance(); - LLScriptEditorWSServer::ptr_t server = - std::static_pointer_cast(wsmgr.findServerByName(server_name)); - - if (!server) - { - server = std::make_shared(server_name, server_port, server_localhost); - wsmgr.addServer(server); - wsmgr.startServer(server_name); - } - - std::string script_id_hash_str(mContainer->getUniqueHash()); - server->associateEditor(getHandle(), script_id_hash_str); - } + mContainer->startWebsocketServer(); // Open it in external editor. { @@ -1687,6 +1666,54 @@ bool LLScriptEdContainer::handleKeyHere(KEY key, MASK mask) return true; } +void LLScriptEdContainer::startWebsocketServer() +{ + // if the user has enabled websockets, create the server to talk to the external editor + { + // TODO: Get the name, port, and locality from settings + std::string server_name(LLScriptEditorWSServer::DEFAULT_SERVER_NAME); + U16 server_port(LLScriptEditorWSServer::DEFAULT_SERVER_PORT); + bool server_localhost(true); + + LLWebsocketMgr& wsmgr = LLWebsocketMgr::instance(); + LLScriptEditorWSServer::ptr_t server = std::static_pointer_cast(wsmgr.findServerByName(server_name)); + + if (!server) + { + server = std::make_shared(server_name, server_port, server_localhost); + wsmgr.addServer(server); + wsmgr.startServer(server_name); + } + + std::string script_id_hash_str(getUniqueHash()); + server->associateEditor(getHandle(), script_id_hash_str); + } +} + +void LLScriptEdContainer::attachToWebSocket(const std::shared_ptr& connection) +{ + mWebSocket = connection; +} + +void LLScriptEdContainer::detachFromWebSocket(bool send_disconnect) +{ + if (mWebSocket) + { + if (send_disconnect) + { + // TODO: + mWebSocket->sendDisconnect(LLScriptEditorWSConnection::REASON_EDITOR_CLOSED); + mWebSocket->closeConnection(); + } + mWebSocket.reset(); + } +} + +void LLScriptEdContainer::cleanupWebSocket() +{ + mWebSocket.reset(); +} + /// --------------------------------------------------------------------------- /// LLPreviewLSL /// --------------------------------------------------------------------------- diff --git a/indra/newview/llpreviewscript.h b/indra/newview/llpreviewscript.h index 14ec54d42b..72d52a115e 100644 --- a/indra/newview/llpreviewscript.h +++ b/indra/newview/llpreviewscript.h @@ -54,6 +54,7 @@ class LLScriptEdContainer; class LLFloaterGotoLine; class LLFloaterExperienceProfile; class LLScriptMovedObserver; +class LLScriptEditorWSConnection; class LLLiveLSLFile : public LLLiveFile { @@ -99,14 +100,14 @@ protected: bool live, S32 bottom_pad = 0); // pad below bottom row of buttons public: - ~LLScriptEdCore(); + ~LLScriptEdCore() override; void initMenu(); void processKeywords(); void processKeywords(bool luau_language); - virtual void draw(); - /*virtual*/ bool postBuild(); + void draw() override; + bool postBuild() override; bool canClose(); void setEnableEditing(bool enable); bool canLoadOrSaveToFile( void* userdata ); @@ -159,6 +160,7 @@ public: void enableSave(bool b) { mEnableSave = b; } bool hasChanged() const; + private: void onBtnDynamicHelp(); void onBtnUndoChanges(); @@ -204,7 +206,7 @@ private: LLScriptEdContainer* mContainer; // parent view -public: + public: boost::signals2::connection mSyntaxIDConnection; }; @@ -218,6 +220,11 @@ public: bool handleKeyHere(KEY key, MASK mask); + void startWebsocketServer(); + void attachToWebSocket(const std::shared_ptr& connection); + void detachFromWebSocket(bool send_disconnect); + void cleanupWebSocket(); + protected: std::string getTmpFileName(const std::string& script_name) const; std::string getUniqueHash() const; @@ -230,6 +237,8 @@ protected: LLScriptEdCore* mScriptEd; LLLiveLSLFile* mLiveFile = nullptr; LLLiveLSLFile* mLiveLogFile = nullptr; + + std::shared_ptr mWebSocket; }; // Used to view and edit an LSL script from your inventory. diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index 503624d15a..9863130aea 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -1,9 +1,10 @@ /** * @file llscripteditorws.cpp + * @brief JSON-RPC 2.0 WebSocket server implementation for external script editor integration * - * $LicenseInfo:firstyear=2002&license=viewerlgpl$ + * $LicenseInfo:firstyear=2025&license=viewerlgpl$ * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. + * Copyright (C) 2025, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,164 +24,24 @@ * $/LicenseInfo$ */ -/* - * ============================================================================ - * WEBSOCKET MESSAGE FORMAT SPECIFICATION - * ============================================================================ - * - * This WebSocket implementation uses a structured JSON message format for - * communication between the Second Life viewer and external script editors. - * All messages are encoded as UTF-8 JSON strings. - * - * ## BASE MESSAGE STRUCTURE - * - * Every WebSocket message follows this mandatory structure: - * - * ```json - * { - * "command": "message_type_identifier", // REQUIRED: Command/message type - * "data": { // OPTIONAL: Command-specific payload - * // ... command-specific fields ... - * }, - * "timestamp": "2025-01-27T15:30:00Z", // OPTIONAL: ISO8601 timestamp - * "session_id": "uuid-string", // OPTIONAL: Session identifier - * "message_id": "unique-id" // OPTIONAL: For request/response correlation - * } - * ``` - * - * ## MESSAGE TYPES - * - * ### 1. SERVER-TO-CLIENT MESSAGES - * - * #### capabilities - * Sent immediately when client connects to announce server capabilities. - * ```json - * { - * "command": "capabilities", - * "data": { - * "server_name": "Second Life Script Editor WebSocket Server", - * "server_version": "1.0.0", - * "protocol_version": "1.0", - * "viewer_name": "Second Life", - * "viewer_version": "Second Life Release 6.4.26", - * "session_id": "generated-uuid", - * "timestamp": "2025-01-27T15:30:00Z", - * "capabilities": ["script_editing", "compilation", "metadata", ...], - * "supported_languages": ["lsl", "luau"], - * "features": { - * "live_compilation": true, - * "debugging": false, - * "breakpoints": false - * } - * } - * } - * ``` - * - * #### error - * Sent when message processing fails or protocol violations occur. - * ```json - * { - * "command": "error", - * "data": { - * "error_code": "PARSE_ERROR|INVALID_MESSAGE|UNKNOWN_MESSAGE_TYPE", - * "error_message": "Human-readable error description" - * } - * } - * ``` - * - * ### 2. CLIENT-TO-SERVER MESSAGES - * - * #### connect - * Client handshake message to establish connection and negotiate capabilities. - * ```json - * { - * "command": "connect", - * "data": { - * "client_name": "VS Code LSL Extension", - * "client_version": "1.2.3", - * "protocol_version": "1.0", - * "capabilities": ["script_editing", "syntax_highlighting"], - * "supported_languages": ["lsl", "luau"], - * "features": { - * "auto_completion": true, - * "live_preview": false - * }, - * "session_id": "optional-client-provided-uuid" - * } - * } - * ``` - * - * ### 3. BIDIRECTIONAL MESSAGES - * - * #### connect_ack - * Server response to client connect message. - * ```json - * { - * "command": "connect_ack", - * "data": { - * "status": "connected|rejected", - * "message": "Connection established successfully", - * "session_id": "established-session-uuid", - * "timestamp": "2025-01-27T15:30:00Z", - * "mutual_capabilities": ["script_editing", "compilation"], - * "supported_languages": ["lsl", "luau"], - * "max_script_size": 65536, - * "heartbeat_interval": 30, - * // For rejected connections: - * "error": "incompatible_protocol|missing_capabilities|connection_failed" - * } - * } - * ``` - * - * ## FUTURE MESSAGE TYPES (Planned) - * - * The following message types are referenced in the protocol design but not - * yet implemented: - * - * - `script_updated`: Editor notifies viewer of script content changes - * - `save_request`: Editor requests script save to SL servers - * - `compile_request`: Editor requests script compilation - * - `script_content`: Viewer sends full script content to editor - * - `compile_result`: Viewer sends compilation results to editor - * - `save_result`: Viewer sends save operation results to editor - * - `metadata`: Script and object metadata exchange - * - `ping`/`pong`: Connection health check messages - * - `editor_ready`: Editor initialization complete notification - * - * ## PROTOCOL RULES - * - * 1. **Encoding**: All messages must be valid UTF-8 JSON - * 2. **Required Fields**: Every message MUST have a "command" field - * 3. **Case Sensitivity**: All field names are case-sensitive - * 4. **Protocol Version**: Currently only "1.0" is supported - * 5. **Error Handling**: Invalid messages trigger "error" responses - * 6. **Connection Flow**: Client must send "connect" before other commands - * 7. **Session Management**: session_id tracks individual editor sessions - * 8. **Capability Negotiation**: Features limited to mutual capabilities - * - * ## ERROR CODES +/** + * This implementation provides JSON-RPC 2.0 WebSocket communication between + * the Second Life viewer and external script editors. It uses the standard + * JSON-RPC 2.0 protocol without pre-defined script-specific methods, + * allowing for flexible integration approaches. * - * - `PARSE_ERROR`: Invalid JSON syntax - * - `PARSE_EXCEPTION`: JSON parsing threw exception - * - `INVALID_MESSAGE`: Missing required "command" field - * - `UNKNOWN_MESSAGE_TYPE`: Unrecognized command type - * - `INCOMPATIBLE_PROTOCOL`: Unsupported protocol version - * - `MISSING_CAPABILITIES`: Required capabilities not supported - * - `CONNECTION_FAILED`: General connection establishment failure + * ## JSON-RPC Integration * - * ## IMPLEMENTATION NOTES + * The connection provides a clean JSON-RPC 2.0 interface that can be + * extended with script-specific functionality as needed: * - * - Messages are parsed using boost::json and converted to LLSD internally - * - All timestamps use ISO 8601 format in UTC timezone - * - UUIDs are generated using LLUUID::generateNewID() for session tracking - * - Maximum script size is currently limited to 65536 bytes - * - WebSocket server binds to localhost only for security by default - * - Protocol designed for extensibility with additional message types + * ### Server-to-Client (Viewer to Editor): + * - `session.handshake`: Welcome message on connection + * - `session.disconnect`: Notify editor of disconnection * - * ============================================================================ + * ### Notifications (no response expected): */ - #include "llviewerprecompiledheaders.h" #include "llscripteditorws.h" #include "llpreviewscript.h" @@ -189,82 +50,42 @@ #include "lldate.h" #include "llerror.h" #include "lluuid.h" -#include "llsdjson.h" -#include - -//------------------------------------------------------------------------ +#include "llversioninfo.h" -LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string_view name, U16 port, bool local_only): - LLWebsocketMgr::WSServer(name, port, local_only) +//======================================================================== +LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only) + : LLJSONRPCServer(name, port, local_only) { + LL_INFOS("ScriptEditorWS") << "Created JSON-RPC script editor server: " << name + << " on port " << port << LL_ENDL; } -LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(WSServer::ptr_t server, LLWebsocketMgr::connection_h handle) +LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, + LLWebsocketMgr::connection_h handle) { - return std::make_shared(server, handle); + auto connection = std::make_shared(server, handle); + mActiveConnections.insert(connection); + + // Call setupConnectionMethods to register any global methods + setupConnectionMethods(connection); + + return connection; } -//------------------------------------------------------------------------ void LLScriptEditorWSServer::onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) { - LL_INFOS("ScriptEditorWS") << "New script editor client connected" << LL_ENDL; - - // Build capabilities message to send to the newly connected external editor - LLSD capabilities_message; - capabilities_message["command"] = "capabilities"; - - LLSD& data = capabilities_message["data"]; - - // Server identification and version information - data["server_name"] = "Second Life Script Editor WebSocket Server"; - data["server_version"] = "1.0.0"; - data["protocol_version"] = "1.0"; + // Call parent class to handle JSON-RPC setup and standard methods + LLJSONRPCServer::onConnectionOpened(connection); - // Viewer information - data["viewer_name"] = LLTrans::getString("APP_NAME"); - data["viewer_version"] = LLAppViewer::instance()->getSecondLifeTitle(); + LL_INFOS("ScriptEditorWS") << "New script editor client connected via JSON-RPC" << LL_ENDL; - // Session information - data["session_id"] = LLUUID::generateNewID().asString(); - data["timestamp"] = LLDate::now().asString(); - - // Server capabilities - what the viewer/server supports - LLSD capabilities = LLSD::emptyArray(); - capabilities.append("script_editing"); // Basic script content editing - capabilities.append("script_synchronization"); // Real-time sync between viewer and editor - capabilities.append("compilation"); // Compile results with errors/warnings - capabilities.append("metadata"); // Script and object metadata - capabilities.append("syntax_highlighting"); // LSL/Luau syntax information - capabilities.append("error_reporting"); // Detailed error reporting - - data["capabilities"] = capabilities; - - // Language support information - LLSD languages = LLSD::emptyArray(); - languages.append("lsl"); // Linden Scripting Language - languages.append("luau"); // Luau scripting language - data["supported_languages"] = languages; - - // Feature flags - LLSD features; - features["live_compilation"] = true; - features["debugging"] = false; // Not implemented yet - features["breakpoints"] = false; // Not implemented yet - data["features"] = features; - - // Send the capabilities message to the newly connected client - if (connection->sendMessage(capabilities_message)) - { - LL_INFOS("ScriptEditorWS") << "Sent capabilities message to new client" << LL_ENDL; - } - else - { - LL_WARNS("ScriptEditorWS") << "Failed to send capabilities message to new client" << LL_ENDL; - } } void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnection::ptr_t& connection) { + // Call parent class to handle JSON-RPC cleanup + LLJSONRPCServer::onConnectionClosed(connection); + LL_INFOS("ScriptEditorWS") << "Script editor client disconnected" << LL_ENDL; // Remove from active connections @@ -273,13 +94,12 @@ void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnecti { mActiveConnections.erase(script_connection); - // Remove from any script associations LL_INFOS("ScriptEditorWS") << "Removed connection from active connections. Total: " << mActiveConnections.size() << LL_ENDL; + // TODO: When connections reach 0, stop the server aftera a timeout. } } -//------------------------------------------------------------------------ bool LLScriptEditorWSServer::associateEditor(const LLHandle& editor_handle, const std::string& script_id) { if (!editor_handle.isDead()) @@ -305,304 +125,268 @@ LLHandle LLScriptEditorWSServer::findEditorForScript(const std::string& return LLHandle(); } -//======================================================================== -void LLScriptEditorWSConnection::onOpen() -{ - -} - -void LLScriptEditorWSConnection::onClose() +std::shared_ptr LLScriptEditorWSServer::findConnectionForScript(const std::string& script_id) { + // TODO: Implement logic to find connection handling a specific script + // This would require tracking which connection is responsible for which script + return nullptr; } -void LLScriptEditorWSConnection::onMessage(const std::string& message) +std::set LLScriptEditorWSServer::getActiveScripts() const { - LL_DEBUGS("ScriptEditorWS") << "Received message: " << message << LL_ENDL; - - // Convert JSON string to LLSD - LLSD parsed_message; - try + std::set active_scripts; + for (const auto& [script_id, editor_handle] : mScriptEditors) { - boost::system::error_code ec; - boost::json::value json_value = boost::json::parse(message, ec); - - if (ec.failed()) + if (!editor_handle.isDead()) { - LL_WARNS("ScriptEditorWS") << "Failed to parse JSON message: " << ec.message() << LL_ENDL; - - // Send error response back to client - LLSD error_response; - error_response["command"] = "error"; - error_response["data"]["error_code"] = "PARSE_ERROR"; - error_response["data"]["error_message"] = "Invalid JSON format: " + std::string(ec.message()); - sendMessage(error_response); - return; + active_scripts.insert(script_id); } - - // Convert boost::json::value to LLSD - parsed_message = LlsdFromJson(json_value); - - LL_DEBUGS("ScriptEditorWS") << "Parsed LLSD message type: " << parsed_message.type() - << ", has 'type' field: " << parsed_message.has("command") << LL_ENDL; - } - catch (const std::exception& e) - { - LL_WARNS("ScriptEditorWS") << "Exception parsing JSON message: " << e.what() << LL_ENDL; - - // Send error response back to client - LLSD error_response; - error_response["command"] = "error"; - error_response["data"]["error_code"] = "PARSE_EXCEPTION"; - error_response["data"]["error_message"] = "JSON parsing exception: " + std::string(e.what()); - sendMessage(error_response); - return; } + return active_scripts; +} - // Validate that we have a proper message structure - if (!parsed_message.has("command")) - { - LL_WARNS("ScriptEditorWS") << "Received message without 'type' field" << LL_ENDL; - - LLSD error_response; - error_response["command"] = "error"; - error_response["data"]["error_code"] = "INVALID_MESSAGE"; - error_response["data"]["error_message"] = "Message must have a 'type' field"; - sendMessage(error_response); - return; - } +void LLScriptEditorWSServer::broadcastScriptUpdate(const std::string& script_id, const std::string& content, const LLSD& metadata) +{ + LL_DEBUGS("ScriptEditorWS") << "Broadcasting script update for script: " << script_id << LL_ENDL; - std::string message_type = parsed_message["command"].asString(); - LL_INFOS("ScriptEditorWS") << "Processing message of type: " << message_type << LL_ENDL; + LLSD params; + params["script_id"] = script_id; + params["content"] = content; + params["timestamp"] = LLDate::now().asString(); - // Route message to appropriate handler based on type - if (message_type == "connect") + if (!metadata.isUndefined()) { - processConnectMessage(parsed_message); + params["metadata"] = metadata; } - else - { - LL_WARNS("ScriptEditorWS") << "Received unknown message type: " << message_type << LL_ENDL; - LLSD error_response; - error_response["command"] = "error"; - error_response["data"]["error_code"] = "UNKNOWN_MESSAGE_TYPE"; - error_response["data"]["error_message"] = "Unknown message type: " + message_type; - sendMessage(error_response); - } + // Send to all connected editors as a notification + broadcastNotification("script.update", params); } -void LLScriptEditorWSConnection::processConnectMessage(const LLSD& message) +void LLScriptEditorWSServer::broadcastCompilationResult(const std::string& script_id, bool success, const LLSD& errors) { - LL_INFOS("ScriptEditorWS") << "Processing connect message from client" << LL_ENDL; + LL_DEBUGS("ScriptEditorWS") << "Broadcasting compilation result for script: " << script_id + << " (success: " << success << ")" << LL_ENDL; - // Extract connection information from the message - LLSD data; - if (message.has("data")) - { - data = message["data"]; - } + LLSD params; + params["script_id"] = script_id; + params["success"] = success; + params["timestamp"] = LLDate::now().asString(); - // Parse client information - std::string client_name; - std::string client_version; - std::string protocol_version; - LLSD client_capabilities; - LLSD supported_languages; - LLSD client_features; - - // Extract client identification - if (data.has("client_name")) + if (!errors.isUndefined() && errors.isArray()) { - client_name = data["client_name"].asString(); - LL_INFOS("ScriptEditorWS") << "Client name: " << client_name << LL_ENDL; + params["errors"] = errors; } - if (data.has("client_version")) - { - client_version = data["client_version"].asString(); - LL_INFOS("ScriptEditorWS") << "Client version: " << client_version << LL_ENDL; - } - - if (data.has("protocol_version")) - { - protocol_version = data["protocol_version"].asString(); - LL_INFOS("ScriptEditorWS") << "Protocol version: " << protocol_version << LL_ENDL; - } + // Send to all connected editors as a notification + broadcastNotification("compilation.result", params); +} - // Extract client capabilities - if (data.has("capabilities")) - { - client_capabilities = data["capabilities"]; - mEditorCapabilities = client_capabilities; // Store for later use - LL_INFOS("ScriptEditorWS") << "Client capabilities count: " << client_capabilities.size() << LL_ENDL; - } +void LLScriptEditorWSServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) +{ + // Call parent class to register global JSON-RPC methods + LLJSONRPCServer::setupConnectionMethods(connection); - // Extract supported languages - if (data.has("supported_languages")) + // Cast to our specific connection type to access script editor functionality + auto script_connection = std::dynamic_pointer_cast(connection); + if (script_connection) { - supported_languages = data["supported_languages"]; - LL_INFOS("ScriptEditorWS") << "Supported languages count: " << supported_languages.size() << LL_ENDL; - } + LL_INFOS("ScriptEditorWS") << "Setting up script editor connection methods" << LL_ENDL; - // Extract client features - if (data.has("features")) - { - client_features = data["features"]; - LL_INFOS("ScriptEditorWS") << "Client features available" << LL_ENDL; - } + // Here derived classes could add script-specific method registrations + // For now, the base LLScriptEditorWSConnection doesn't register any specific methods + // but this provides a hook for future customization - // Generate or extract editor session ID - if (data.has("session_id")) - { - mEditorId = data["session_id"].asString(); - LL_INFOS("ScriptEditorWS") << "Using client session ID: " << mEditorId << LL_ENDL; - } - else - { - // Generate a new session ID if client didn't provide one - mEditorId = LLUUID::generateNewID().asString(); - LL_INFOS("ScriptEditorWS") << "Generated session ID: " << mEditorId << LL_ENDL; + // Example of how custom methods could be registered: + // script_connection->registerMethod("script.custom", handler); } +} - // Validate protocol compatibility - bool protocol_compatible = true; - if (!protocol_version.empty()) - { - // For now, we only support protocol version "1.0" - if (protocol_version != "1.0") - { - protocol_compatible = false; - LL_WARNS("ScriptEditorWS") << "Unsupported protocol version: " << protocol_version - << ", expected: 1.0" << LL_ENDL; - } - } +//======================================================================== +LLScriptEdContainer* LLScriptEditorWSConnection::getEditor() const +{ + return mEditorPanel.isDead() ? nullptr : dynamic_cast(mEditorPanel.get()); +} - // Determine if we have feature compatibility - bool has_script_editing = false; - if (client_capabilities.isArray()) - { - for (LLSD::array_const_iterator it = client_capabilities.beginArray(); - it != client_capabilities.endArray(); ++it) - { - if (it->asString() == "script_editing") - { - has_script_editing = true; - break; - } - } - } +std::shared_ptr LLScriptEditorWSConnection::getServer() const +{ + return std::static_pointer_cast(mOwningServer.lock()); +} - // Build response message - LLSD response; - response["command"] = "connect_ack"; +void LLScriptEditorWSConnection::onOpen() +{ + // Call parent class to set up JSON-RPC infrastructure + LLJSONRPCConnection::onOpen(); - LLSD& response_data = response["data"]; + LL_INFOS("ScriptEditorWS") << "Script editor JSON-RPC connection opened" << LL_ENDL; - if (protocol_compatible && has_script_editing) - { - // Successful connection - response_data["status"] = "connected"; - response_data["message"] = "Connection established successfully"; - response_data["session_id"] = mEditorId; - response_data["timestamp"] = LLDate::now().asString(); + // Generate unique editor session ID + mEditorId = LLUUID::generateNewID().asString(); + mEditorReady = false; - // Send back our supported capabilities that match the client's - LLSD mutual_capabilities = LLSD::emptyArray(); + LL_INFOS("ScriptEditorWS") << "Initialized editor session: " << mEditorId << LL_ENDL; - // Check which capabilities we both support - if (client_capabilities.isArray()) - { - // Our server capabilities (from onConnectionOpened) - std::set server_caps = { - "script_editing", "script_synchronization", "compilation", - "metadata", "syntax_highlighting", "error_reporting" - }; - - for (LLSD::array_const_iterator it = client_capabilities.beginArray(); - it != client_capabilities.endArray(); ++it) - { - std::string cap = it->asString(); - if (server_caps.count(cap) > 0) - { - mutual_capabilities.append(cap); - } - } - } + // Build hello data according to the protocol specification + LLSD handshake; + handshake["server_version"] = "1.0.0"; + handshake["protocol_version"] = "1.0"; + handshake["viewer_name"] = LLVersionInfo::instance().getChannel(); + handshake["viewer_version"] = LLVersionInfo::instance().getVersion(); - response_data["mutual_capabilities"] = mutual_capabilities; + // Supported languages array + LLSD languages = LLSD::emptyArray(); + languages.append("lsl"); + languages.append("luau"); + handshake["supported_languages"] = languages; - // Send supported languages intersection - LLSD mutual_languages = LLSD::emptyArray(); - if (supported_languages.isArray()) + // Features object + LLSD features; + features["live_sync"] = true; + features["compilation"] = true; + features["syntax_highlight"] = true; + handshake["features"] = features; + + // Send editor.handshake method call to the client and handle response + call("session.handshake", handshake, [this](const LLSD& result, const LLSD& error) { + if (error.isUndefined()) { - std::set server_languages = {"lsl", "luau"}; - - for (LLSD::array_const_iterator it = supported_languages.beginArray(); - it != supported_languages.endArray(); ++it) - { - std::string lang = it->asString(); - if (server_languages.count(lang) > 0) - { - mutual_languages.append(lang); - } - } + handleHandshakeResponse(result); } else { - // Default to all our supported languages if client didn't specify - mutual_languages.append("lsl"); - mutual_languages.append("luau"); + LL_WARNS("ScriptEditorWS") << "Handshake failed: " + << error["message"].asString() << LL_ENDL; } + }); - response_data["supported_languages"] = mutual_languages; + LL_INFOS("ScriptEditorWS") << "Sent handshake call to new editor client" << LL_ENDL; +} - // Connection limits and constraints - response_data["max_script_size"] = 65536; - response_data["heartbeat_interval"] = 30; +void LLScriptEditorWSConnection::onClose() +{ + // Call parent class to clean up JSON-RPC infrastructure + LLJSONRPCConnection::onClose(); + + LL_INFOS("ScriptEditorWS") << "Script editor JSON-RPC connection closed for session: " + << mEditorId << LL_ENDL; + + cleanupConnection(); + + // Clean up editor-specific state + mEditorId.clear(); + mEditorCapabilities.clear(); + mScriptId.clear(); + mEditorReady = false; + + // Clean up handshake response data + mClientName.clear(); + mClientVersion.clear(); + mProtocolVersion.clear(); + mScriptName.clear(); + mScriptLanguage.clear(); + mLanguages.clear(); + mFeatures.clear(); +} - LL_INFOS("ScriptEditorWS") << "Successfully connected client: " << client_name - << " v" << client_version - << " with " << mutual_capabilities.size() << " mutual capabilities" << LL_ENDL; - } - else +void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) +{ + LL_INFOS("ScriptEditorWS") << "Processing handshake response from client" << LL_ENDL; + + // Extract and validate client information + mClientName = result["client_name"].asString(); + mClientVersion = result["client_version"].asString(); + mProtocolVersion = result["protocol_version"].asString(); + + // Validate protocol compatibility + if (mProtocolVersion != "1.0") { - // Connection failed - response_data["status"] = "rejected"; + LL_WARNS("ScriptEditorWS") << "Protocol version mismatch. Expected: 1.0, Got: " + << mProtocolVersion << LL_ENDL; + } - if (!protocol_compatible) - { - response_data["error"] = "incompatible_protocol"; - response_data["message"] = "Unsupported protocol version: " + protocol_version; - } - else if (!has_script_editing) + // Store script information if provided + mScriptName = result["script_name"].asString(); + mScriptLanguage = result["script_language"].asString(); + mScriptId = result["script_id"].asString(); + + // Store supported languages + for (const auto& lang : llsd::inArray( result["languages"])) + { + if (lang.isString()) { - response_data["error"] = "missing_capabilities"; - response_data["message"] = "Client must support 'script_editing' capability"; + mLanguages.insert(lang.asString()); } - else + } + + for (const auto& [feature, enabled] : llsd::inMap(result["features"])) + { + if (enabled.asBoolean()) { - response_data["error"] = "connection_failed"; - response_data["message"] = "Connection failed for unknown reason"; + mFeatures.insert(feature); } + } + + connectToEditor(mScriptId); + // Mark editor as ready + mEditorReady = true; + + LL_INFOS("ScriptEditorWS") << "Handshake completed successfully for session: " << mEditorId << LL_ENDL; +} - LL_WARNS("ScriptEditorWS") << "Rejected connection from client: " << client_name - << " - " << response_data["message"].asString() << LL_ENDL; +bool LLScriptEditorWSConnection::connectToEditor(const std::string& script_id) +{ + LLScriptEditorWSServer::ptr_t server = std::dynamic_pointer_cast(mOwningServer.lock()); + if (!server) + { + LL_WARNS("ScriptEditorWS") << "Cannot connect to editor - server reference lost" << LL_ENDL; + return false; } - // Send the response back to the client - if (sendMessage(response)) + mEditorPanel = server->findEditorForScript(script_id); + + LLScriptEdContainer* editor_core = getEditor(); + if (!editor_core) { - LL_INFOS("ScriptEditorWS") << "Sent connect acknowledgment to client" << LL_ENDL; + LL_INFOS("ScriptEditorWS") << "Could not find editor: " << script_id << LL_ENDL; + // TODO: Disconnect the client if no editor found + return false; } - else + + return true; +} + +void LLScriptEditorWSConnection::cleanupConnection() +{ + LL_INFOS("ScriptEditorWS") << "Cleaning up connection for editor session: " << mEditorId << LL_ENDL; + + LLScriptEditorWSServer::ptr_t server = getServer(); + if (server) { - LL_WARNS("ScriptEditorWS") << "Failed to send connect acknowledgment to client" << LL_ENDL; + server->dissociateEditor(mScriptId); } - // If connection was successful, we could also send any initial state or configuration - if (response_data["status"].asString() == "connected") + LLScriptEdContainer* editor_core = getEditor(); + + if (editor_core) { - // TODO: Send initial script list, active editors, or other relevant state - // Example: sendScriptList(), sendActiveEditors(), etc. + editor_core->cleanupWebSocket(); + + // Notify the editor panel of disconnection + //editor_core->onExternalEditorDisconnected(); } + + mEditorPanel = LLHandle(); +} + + +void LLScriptEditorWSConnection::sendDisconnect(S32 reason, const std::string& message) +{ + LL_INFOS("ScriptEditorWS") << "Sending disconnect message to editor (reason: " + << reason << ", message: " << message << ")" << LL_ENDL; + + LLSD params; + params["reason"] = reason; + params["message"] = message; + + notify("session.disconnect", params); } diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h index 73efb1a65f..78c675a1f4 100644 --- a/indra/newview/llscripteditorws.h +++ b/indra/newview/llscripteditorws.h @@ -26,7 +26,7 @@ #pragma once -#include "llwebsocketmgr.h" +#include "lljsonrpcws.h" #include "llsd.h" #include "lluuid.h" #include "llhandle.h" @@ -39,48 +39,43 @@ // Forward declarations class LLLiveLSLEditor; -class LLScriptEdCore; +class LLScriptEdContainer; +class LLScriptEditorWSServer; /** * @class LLScriptEditorWSConnection - * @brief WebSocket connection specialized for external script editor communication - * - * This class handles WebSocket communication between the Second Life viewer - * and external script editors. It manages script content synchronization, - * compilation status updates, and editor metadata exchange. - * - * ## Message Protocol - * - * The connection uses JSON messages with the following structure: - * - `type`: Message type identifier - * - `data`: Message payload (varies by type) - * - `timestamp`: Message timestamp for ordering - * - `id`: Optional message ID for request/response correlation - * - * ### Supported Message Types: - * - * #### From Editor to Viewer: - * - `script_updated`: Script content has been modified - * - `save_request`: Request to save script to SL servers - * - `compile_request`: Request to compile script - * - `editor_ready`: Editor initialization complete - * - `ping`: Connection health check - * - * #### From Viewer to Editor: - * - `script_content`: Full script content - * - `compile_result`: Compilation success/failure with errors - * - `save_result`: Save operation result - * - `metadata`: Script and object metadata - * - `pong`: Response to ping + * @brief JSON-RPC WebSocket connection specialized for external script editor communication + * + * This class handles JSON-RPC 2.0 communication between the Second Life viewer + * and external script editors. It provides a clean base for implementing + * script editor integration using the standard JSON-RPC 2.0 protocol. + * + * ## Usage + * + * @code + * // Create server and let base JSON-RPC handle method registration + * auto server = std::make_shared("script_editor_server", 9020); + * + * // Register custom methods as needed + * connection->registerMethod("custom.method", handler); + * @endcode */ -class LLScriptEditorWSConnection : public LLWebsocketMgr::WSConnection +class LLScriptEditorWSConnection : public LLJSONRPCConnection, + public std::enable_shared_from_this { public: + enum DisconnectReason + { + REASON_NORMAL = 0, + REASON_EDITOR_CLOSED = 1, + REASON_PROTOCOL_ERROR = 2, + REASON_TIMEOUT = 3, + REASON_INTERNAL_ERROR = 4 + }; LLScriptEditorWSConnection(const LLWebsocketMgr::WSServer::ptr_t server, - const LLWebsocketMgr::connection_h& handle): - LLWebsocketMgr::WSConnection(server, handle), - mMessageSequence(0) + const LLWebsocketMgr::connection_h& handle) + : LLJSONRPCConnection(server, handle) { } ~LLScriptEditorWSConnection() override = default; @@ -89,32 +84,57 @@ public: // Connection lifecycle overrides void onOpen() override; void onClose() override; - void onMessage(const std::string& message) override; + + /** + * @brief Send session disconnect message to the external editor + * @param reason Numeric reason code for the disconnect (default 0 for normal closure) + * @param message Human-readable disconnect message (default "Goodbye") + */ + void sendDisconnect(S32 reason = 0, const std::string& message = "Goodbye"); private: + using string_set_t = std::set; /** - * @brief Handle connect/connection messages from editor - * @param message Parsed LLSD message + * @brief Handle the handshake response from the client + * @param result The response data from the client containing client information */ - void processConnectMessage(const LLSD& message); + void handleHandshakeResponse(const LLSD& result); + + bool connectToEditor(const std::string& script_id); + void cleanupConnection(); + + LLScriptEdContainer* getEditor() const; + std::shared_ptr getServer() const; std::string mEditorId; ///< Unique identifier for this editor session LLSD mEditorCapabilities; ///< Editor capabilities metadata - U32 mMessageSequence; ///< Message sequence counter std::string mScriptId; ///< Unique identifier for the script being edited + bool mEditorReady; ///< Whether editor has completed initialization + LLHandle mEditorPanel; ///< Handle to the associated LSL editor panel + + // Client handshake response data + std::string mClientName; ///< Name of the external editor client + std::string mClientVersion; ///< Version of the external editor client + std::string mProtocolVersion; ///< JSON-RPC protocol version supported by client + std::string mScriptName; ///< Name of the script being edited + std::string mScriptLanguage; ///< Programming language of the script (lsl, luau, etc.) + string_set_t mLanguages; ///< Set of supported scripting languages + string_set_t mFeatures; ///< Active client features (live_sync, compilation, etc.) }; /** * @class LLScriptEditorWSServer - * @brief WebSocket server for external script editor integration + * @brief JSON-RPC 2.0 WebSocket server for external script editor integration * - * This server manages WebSocket connections from external script editors, - * providing a bridge between the Second Life viewer's script editing - * functionality and external development tools. + * This server extends the JSON-RPC server to provide specialized functionality + * for external script editor integration. It manages WebSocket connections from + * external script editors and provides a structured JSON-RPC 2.0 interface + * between the Second Life viewer's script editing functionality and external + * development tools. * * ## Architecture * - * The server acts as a communication hub between: + * The server acts as a JSON-RPC communication hub between: * - LLLiveLSLEditor instances (in-world script editing) * - External script editors (VS Code, Atom, Sublime Text, etc.) * - Script compilation and save services @@ -122,8 +142,8 @@ private: * ## Usage * * @code - * // Create and start the server - * auto server = std::make_shared("script_editor_server", 8080); + * // Create and start the JSON-RPC server + * auto server = std::make_shared("script_editor_server", 9020); * LLWebsocketMgr::getInstance()->addServer(server); * LLWebsocketMgr::getInstance()->startServer("script_editor_server"); * @@ -134,11 +154,11 @@ private: * ## Security Considerations * * - Server binds to localhost only by default for security - * - Editor authentication via connection handshake - * - Script content encryption for sensitive projects - * - Rate limiting to prevent abuse + * - JSON-RPC 2.0 structured protocol with validation + * - Rate limiting handled by base JSON-RPC server + * - Error handling with standardized JSON-RPC error codes */ -class LLScriptEditorWSServer : public LLWebsocketMgr::WSServer +class LLScriptEditorWSServer : public LLJSONRPCServer { public: static constexpr char const* DEFAULT_SERVER_NAME = "script_editor_server"; @@ -146,7 +166,7 @@ public: using ptr_t = std::shared_ptr; - LLScriptEditorWSServer(const std::string_view name, U16 port, bool local_only = true); + LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only = true); virtual ~LLScriptEditorWSServer() = default; @@ -166,14 +186,40 @@ public: */ std::set getActiveScripts() const; + /** + * @brief Send script content to all connected editors for a specific script + * @param script_id The script identifier + * @param content The script content + * @param metadata Optional metadata about the script + */ + void broadcastScriptUpdate(const std::string& script_id, const std::string& content, const LLSD& metadata = LLSD()); + + /** + * @brief Send compilation results to all connected editors for a specific script + * @param script_id The script identifier + * @param success Whether compilation succeeded + * @param errors Array of compilation errors/warnings + */ + void broadcastCompilationResult(const std::string& script_id, bool success, const LLSD& errors = LLSD()); + protected: - LLWebsocketMgr::WSConnection::ptr_t connectionFactory(WSServer::ptr_t server, LLWebsocketMgr::connection_h handle) override; + LLWebsocketMgr::WSConnection::ptr_t connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, + LLWebsocketMgr::connection_h handle) override; + + /** + * @brief Apply global method handlers to a new connection + * @param connection The connection to configure + * + * Override this method to customize which methods are registered on + * new connections. The base implementation registers all global methods, + * but derived classes can add additional script-specific methods. + */ + virtual void setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) override; private: - using map_id_to_editor_t = std::unordered_map >; + using map_id_to_editor_t = std::unordered_map>; map_id_to_editor_t mScriptEditors; - std::set> mActiveConnections; /** -- cgit v1.3 From 684af8426b36f9ad4c2324ae0c5b4dc62f840079 Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Wed, 17 Sep 2025 13:14:23 -0700 Subject: initial Lua types files, and switch websocket server to use a single connection for all scripts. --- indra/llcommon/llstl.h | 204 +++++++++++++++++ indra/llcorehttp/llwebsocketmgr.cpp | 31 +++ indra/llcorehttp/llwebsocketmgr.h | 62 ++---- indra/newview/CMakeLists.txt | 2 + indra/newview/llpreviewscript.cpp | 48 ++-- indra/newview/llpreviewscript.h | 11 +- indra/newview/llscripteditorws.cpp | 423 +++++++++++++++++++++++------------- indra/newview/llscripteditorws.h | 141 ++++++------ indra/newview/llsyntaxid.cpp | 17 +- indra/newview/llsyntaxid.h | 22 +- 10 files changed, 650 insertions(+), 311 deletions(-) (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/llcommon/llstl.h b/indra/llcommon/llstl.h index 7d41c42ba7..0088eeec67 100644 --- a/indra/llcommon/llstl.h +++ b/indra/llcommon/llstl.h @@ -35,6 +35,7 @@ #include #include #include +#include #ifdef LL_LINUX // For strcmp @@ -709,5 +710,208 @@ struct ll_template_cast_impl \ } \ } +//----------------------------------------------- +namespace LL +{ + /** + * @brief A range adapter that provides filtered iteration over a container. + * + * filter_range creates a filtered view of an iterator range using a predicate function. + * Only elements that satisfy the predicate will be accessible when iterating through + * the range. This is useful for processing subsets of containers without copying data. + * + * The class uses boost::filter_iterator internally to provide the filtering functionality. + * + * @tparam Predicate A callable object (function, functor, lambda) that takes an element + * from the iterator range and returns true if the element should be + * included in the filtered range. + * @tparam Iterator The iterator type for the underlying container/range. + * + * Example usage: + * @code + * std::vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + * + * // Create a predicate to filter even numbers + * auto is_even = [](int n) { return n % 2 == 0; }; + * + * // Create filtered range using make_filter helper + * auto even_range = LL::make_filter(is_even, numbers.begin(), numbers.end()); + * + * // Iterate through only even numbers + * for (auto value : even_range) { + * std::cout << value << " "; // Prints: 2 4 6 8 10 + * } + * + * // Or manually construct the filter_range + * LL::filter_range::iterator> + * manual_range(is_even, numbers.begin(), numbers.end()); + * @endcode + * + * @note This class provides a lightweight view over the original data. + * No copying of elements occurs, making it efficient for large containers. + * @note The predicate is applied during iteration, so complex predicates may + * impact performance for frequently-accessed ranges. + * @note The underlying container must remain valid for the lifetime of the filter_range. + * + * @see make_filter() for a convenient factory function + * @see boost::filter_iterator for the underlying implementation details + */ + template + class filter_range + { + public: + /// The filtered iterator type - combines predicate with base iterator + using filter_iter = boost::filter_iterator; + + /// Value type of the filtered elements + using value_type = typename std::iterator_traits::value_type; + + /// Iterator type for range-based for loops and STL algorithms + using iterator = filter_iter; + using const_iterator = filter_iter; + + /** + * @brief Constructs a filter_range with the given predicate and iterator range. + * + * @param pred The predicate function/functor to filter elements. + * Must be callable with signature: bool(const value_type&) + * @param begin Iterator to the beginning of the range to filter + * @param end Iterator to the end of the range to filter + * + * @pre begin and end must form a valid iterator range + * @pre pred must be a valid callable that can be invoked with elements from [begin, end) + */ + filter_range(Predicate pred, Iterator begin, Iterator end) + : begin_(pred, begin, end), end_(pred, end, end) {} + + /** + * @brief Returns an iterator to the first element that satisfies the predicate. + * + * @return filter_iter Iterator pointing to the first filtered element, + * or equal to end() if no elements satisfy the predicate. + */ + filter_iter begin() const { return begin_; } + + /** + * @brief Returns an iterator representing the end of the filtered range. + * + * @return filter_iter Past-the-end iterator for the filtered range. + */ + filter_iter end() const { return end_; } + + /** + * @brief Checks if the filtered range is empty. + * + * @return true if no elements in the range satisfy the predicate, false otherwise. + * + * @note This operation has O(1) complexity as it only compares iterators. + */ + bool empty() const { return begin_ == end_; } + + private: + filter_iter begin_; ///< Iterator to first element satisfying predicate + filter_iter end_; ///< Past-the-end iterator for the filtered range + }; + + /** + * @brief Factory function to create a filter_range with automatic template deduction. + * + * This convenience function eliminates the need to explicitly specify template parameters + * when creating a filter_range. The template parameters are automatically deduced from + * the function arguments. + * + * @tparam Predicate Automatically deduced predicate type + * @tparam Iterator Automatically deduced iterator type + * + * @param pred Predicate function/functor for filtering elements + * @param begin Iterator to the beginning of the range + * @param end Iterator to the end of the range + * + * @return filter_range A filter_range object configured with + * the provided predicate and range + * + * Example usage: + * @code + * std::vector words = {"hello", "world", "test", "example"}; + * + * // Filter strings longer than 4 characters + * auto long_words = LL::make_filter( + * [](const std::string& s) { return s.length() > 4; }, + * words.begin(), + * words.end() + * ); + * + * // Use with range-based for loop + * for (const auto& word : long_words) { + * std::cout << word << std::endl; // Prints: hello, world, example + * } + * + * // Use with STL algorithms + * auto count = std::distance(long_words.begin(), long_words.end()); + * std::cout << "Found " << count << " long words." << std::endl; + * @endcode + * + * @note This function is preferred over direct construction of filter_range + * for most use cases due to automatic template parameter deduction. + */ + template + filter_range make_filter(Predicate pred, Iterator begin, Iterator end) + { + return filter_range(pred, begin, end); + } + + /** + * @brief Create a filter_range over an entire container with automatic template deduction. + * + * This convenience function creates a filtered view over an entire container without + * requiring explicit begin() and end() calls. It automatically handles both const and + * non-const containers, preserving constness in the resulting iterator types. + * + * @tparam Predicate Automatically deduced predicate type + * @tparam Container Automatically deduced container type (const or non-const) + * + * @param pred Predicate function/functor for filtering elements + * @param container The container to filter (can be const or non-const) + * + * @return filter_range with appropriate iterator type for the container + * + * Example usage: + * @code + * // Non-const container + * std::vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + * auto evens = LL::make_filter([](int n) { return n % 2 == 0; }, numbers); + * + * // Const container + * const std::list words = {"cat", "elephant", "dog", "hippopotamus"}; + * auto long_words = LL::make_filter([](const std::string& s) { return s.size() > 3; }, words); + * + * // Works with any container that supports begin()/end() + * std::set values = {1.1, 2.2, 3.3, 4.4, 5.5}; + * auto large_values = LL::make_filter([](double d) { return d > 3.0; }, values); + * + * // Use with range-based for loops + * for (const auto& word : long_words) { + * std::cout << word << " "; // Prints: elephant hippopotamus + * } + * + * // Chain with STL algorithms + * auto even_count = std::distance(evens.begin(), evens.end()); + * std::cout << "Found " << even_count << " even numbers." << std::endl; + * @endcode + * + * @note This overload automatically calls begin() and end() on the container, + * making it more convenient than the iterator-based version. + * @note The container must remain valid for the lifetime of the returned filter_range. + * @note Constness of the container is preserved in the iterator type. + */ + template + filter_range()))> + make_filter(Predicate pred, Container&& container) + { + return filter_range()))>( + pred, std::begin(container), std::end(container)); + } + +} // namespace LL #endif // LL_LLSTL_H diff --git a/indra/llcorehttp/llwebsocketmgr.cpp b/indra/llcorehttp/llwebsocketmgr.cpp index d44d5d877d..09eb728500 100644 --- a/indra/llcorehttp/llwebsocketmgr.cpp +++ b/indra/llcorehttp/llwebsocketmgr.cpp @@ -485,6 +485,7 @@ bool LLWebsocketMgr::WSServer::start() LL_INFOS("WebSocket") << "WebSocket server thread exiting for: " << mServerName << LL_ENDL; }); + onStarted(); LL_INFOS("WebSocket") << "Started WebSocket server thread: " << mServerName << LL_ENDL; return true; } @@ -517,6 +518,7 @@ void LLWebsocketMgr::WSServer::stop() mServerThread.join(); LL_INFOS("WebSocket") << "WebSocket server thread joined for: " << mServerName << LL_ENDL; } + onStopped(); } bool LLWebsocketMgr::WSServer::isRunning() const @@ -596,6 +598,20 @@ LLWebsocketMgr::WSConnection::ptr_t LLWebsocketMgr::WSServer::getConnection(cons return nullptr; } +LLWebsocketMgr::connection_state_t LLWebsocketMgr::WSServer::getConnectionState(const connection_h& handle) const +{ + websocketpp::lib::error_code ec; + auto con = mImpl->mServer.get_con_from_hdl(handle, ec); + if (ec) + { + LL_WARNS("WebSocket") << mServerName << " failed to get connection state: " << ec.message() << LL_ENDL; + websocketpp::session::state::value state = websocketpp::session::state::closed; + return connection_closed; + } + return static_cast(con->get_state()); +} + + void LLWebsocketMgr::WSServer::handleOpenConnection(const connection_h& handle) { WSConnection::ptr_t connection; @@ -709,3 +725,18 @@ void LLWebsocketMgr::WSConnection::closeConnection(U16 code, const std::string& LL_WARNS("WebSocket") << "Failed to close connection through server" << LL_ENDL; } } + +bool LLWebsocketMgr::WSConnection::isConnected() const +{ + if (mOwningServer.expired()) + { + return false; + } + + LLWebsocketMgr::WSServer::ptr_t server = mOwningServer.lock(); + if (!server) + { + return false; + } + return server->getConnectionState(mConnectionHandle) == connection_open; +} diff --git a/indra/llcorehttp/llwebsocketmgr.h b/indra/llcorehttp/llwebsocketmgr.h index 570c8ad6cd..4165b3cecc 100644 --- a/indra/llcorehttp/llwebsocketmgr.h +++ b/indra/llcorehttp/llwebsocketmgr.h @@ -64,6 +64,14 @@ public: using connection_h = websocketpp::connection_hdl; class WSServer; + enum connection_state_t + { // must map to websocketpp::session::state + connection_connecting = 0, + connection_open = 1, + connection_closing = 2, + connection_closed = 3 + }; + class WSConnection { friend class LLWebsocketMgr; @@ -84,8 +92,6 @@ public: virtual ~WSConnection() = default; /** - * @brief Called when the connection is opened - * * Override this method in derived classes to handle connection establishment. * This is called after the WebSocket handshake is complete and the connection * is ready to send/receive messages. @@ -93,8 +99,6 @@ public: virtual void onOpen() {} /** - * @brief Called when the connection is closed - * * Override this method in derived classes to handle connection closure. * This is called when the connection has been terminated, either normally * or due to an error condition. @@ -107,27 +111,6 @@ public: * * Override this method in derived classes to handle incoming messages. * Currently only text messages are supported. - * - * @code - * class MyConnection : public LLWebsocketMgr::WSConnection - * { - * public: - * void onMessage(const std::string& message) override - * { - * // Parse and handle the message - * if (message == "ping") { - * sendMessage("pong"); - * } - * // Process JSON messages - * try { - * LLSD data = LLSDSerialize::fromJSON(message); - * handleStructuredMessage(data); - * } catch (...) { - * LL_WARNS("MyConnection") << "Invalid JSON received" << LL_ENDL; - * } - * } - * }; - * @endcode */ virtual void onMessage(const std::string& message) {} @@ -138,17 +121,6 @@ public: * * Sends a text message to the remote endpoint. The message is queued * asynchronously and may not be sent immediately. - * - * @code - * // Send a simple text message - * connection->sendMessage("Hello, client!"); - * - * // Send JSON data - * LLSD response; - * response["status"] = "ok"; - * response["data"] = "some data"; - * connection->sendMessage(LLSDSerialize::toJSON(response)); - * @endcode */ bool sendMessage(const std::string& message) const; bool sendMessage(const boost::json::value& json) const; @@ -172,22 +144,13 @@ public: * - 1008: Policy violation * - 1009: Message too big * - * @code - * // Normal closure - * connection->closeConnection(); - * - * // Close with specific reason - * connection->closeConnection(1000, "Session ended"); - * - * // Close due to policy violation - * connection->closeConnection(1008, "Authentication failed"); - * @endcode - * * @note After calling this method, no further messages should be sent * @note The onClose() callback will be invoked when the close handshake completes */ void closeConnection(U16 code = 1000, const std::string& reason = std::string()); + bool isConnected() const; + protected: connection_h mConnectionHandle; std::weak_ptr mOwningServer; // Back-reference to the server this connection belongs to @@ -260,6 +223,9 @@ public: WSServer(std::string_view name, U16 port, bool local_only = true); virtual ~WSServer(); + virtual void onStarted() {} + virtual void onStopped() {} + virtual void onConnectionOpened(const WSConnection::ptr_t& connection) { } virtual void onConnectionClosed(const WSConnection::ptr_t& connection) { } @@ -273,6 +239,8 @@ public: void broadcastMessage(const std::string& message); virtual bool update() { return true; } + connection_state_t getConnectionState(const connection_h& handle) const; + protected: virtual WSConnection::ptr_t connectionFactory(WSServer::ptr_t server, connection_h handle); diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index d1527ef578..6c7b4fef81 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -1663,6 +1663,7 @@ set(viewer_APPSETTINGS_FILES app_settings/ignorable_dialogs.xml app_settings/key_bindings.xml app_settings/keywords_lsl_default.xml + app_settings/keywords_lua_default.xml app_settings/logcontrol.xml app_settings/settings.xml app_settings/settings_crash_behavior.xml @@ -1671,6 +1672,7 @@ set(viewer_APPSETTINGS_FILES app_settings/std_bump.ini app_settings/toolbars.xml app_settings/trees.xml + app_settings/types_lua_default.llsd app_settings/viewerart.xml app_settings/message.xml ${CMAKE_SOURCE_DIR}/../scripts/messages/message_template.msg diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp index 3ab2e747ea..f17b2aeed1 100644 --- a/indra/newview/llpreviewscript.cpp +++ b/indra/newview/llpreviewscript.cpp @@ -1553,6 +1553,11 @@ LLScriptEdContainer::~LLScriptEdContainer() delete mLiveLogFile; mLiveLogFile = nullptr; + + if (!mWebSocketServer.expired()) + { + unsubscribeScript(); + } } std::string LLScriptEdContainer::getTmpFileName(const std::string& script_name) const @@ -1675,44 +1680,45 @@ void LLScriptEdContainer::startWebsocketServer() U16 server_port(LLScriptEditorWSServer::DEFAULT_SERVER_PORT); bool server_localhost(true); + // Attempt to find an existing server LLWebsocketMgr& wsmgr = LLWebsocketMgr::instance(); LLScriptEditorWSServer::ptr_t server = std::static_pointer_cast(wsmgr.findServerByName(server_name)); if (!server) - { + { // We couldn't find one, so create it server = std::make_shared(server_name, server_port, server_localhost); wsmgr.addServer(server); - wsmgr.startServer(server_name); + } + + bool is_running = server->isRunning(); + if (!is_running) + { // Server isn't running, so start it + is_running = wsmgr.startServer(server_name); + } + + if (!is_running && !server->isRunning()) + { // Failed to start the server + LL_WARNS() << "Failed to start script editor websocket server" << LL_ENDL; + return; } std::string script_id_hash_str(getUniqueHash()); - server->associateEditor(getHandle(), script_id_hash_str); + server->subscribeScriptEditor(getHandle(), script_id_hash_str); + mWebSocketServer = server; } } -void LLScriptEdContainer::attachToWebSocket(const std::shared_ptr& connection) +void LLScriptEdContainer::unsubscribeScript() { - mWebSocket = connection; -} - -void LLScriptEdContainer::detachFromWebSocket(bool send_disconnect) -{ - if (mWebSocket) + auto server = mWebSocketServer.lock(); + if (server) { - if (send_disconnect) - { - // TODO: - mWebSocket->sendDisconnect(LLScriptEditorWSConnection::REASON_EDITOR_CLOSED); - mWebSocket->closeConnection(); - } - mWebSocket.reset(); + std::string script_id_hash_str(getUniqueHash()); + server->sendUnsubscribeScriptEditor(script_id_hash_str); + server->unsubscribeEditor(script_id_hash_str); } } -void LLScriptEdContainer::cleanupWebSocket() -{ - mWebSocket.reset(); -} /// --------------------------------------------------------------------------- /// LLPreviewLSL diff --git a/indra/newview/llpreviewscript.h b/indra/newview/llpreviewscript.h index 72d52a115e..8d53c8899c 100644 --- a/indra/newview/llpreviewscript.h +++ b/indra/newview/llpreviewscript.h @@ -54,7 +54,7 @@ class LLScriptEdContainer; class LLFloaterGotoLine; class LLFloaterExperienceProfile; class LLScriptMovedObserver; -class LLScriptEditorWSConnection; +class LLScriptEditorWSServer; class LLLiveLSLFile : public LLLiveFile { @@ -105,6 +105,7 @@ public: void initMenu(); void processKeywords(); void processKeywords(bool luau_language); + LLKeywords& getKeywords() { return mEditor->getKeywords(); } void draw() override; bool postBuild() override; @@ -221,9 +222,9 @@ public: bool handleKeyHere(KEY key, MASK mask); void startWebsocketServer(); - void attachToWebSocket(const std::shared_ptr& connection); - void detachFromWebSocket(bool send_disconnect); - void cleanupWebSocket(); + void unsubscribeScript(); + + LLScriptEdCore* getScriptEdCore() const { return mScriptEd; } protected: std::string getTmpFileName(const std::string& script_name) const; @@ -238,7 +239,7 @@ protected: LLLiveLSLFile* mLiveFile = nullptr; LLLiveLSLFile* mLiveLogFile = nullptr; - std::shared_ptr mWebSocket; + std::weak_ptr mWebSocketServer; }; // Used to view and edit an LSL script from your inventory. diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index 9863130aea..cb67880455 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -24,24 +24,6 @@ * $/LicenseInfo$ */ -/** - * This implementation provides JSON-RPC 2.0 WebSocket communication between - * the Second Life viewer and external script editors. It uses the standard - * JSON-RPC 2.0 protocol without pre-defined script-specific methods, - * allowing for flexible integration approaches. - * - * ## JSON-RPC Integration - * - * The connection provides a clean JSON-RPC 2.0 interface that can be - * extended with script-specific functionality as needed: - * - * ### Server-to-Client (Viewer to Editor): - * - `session.handshake`: Welcome message on connection - * - `session.disconnect`: Notify editor of disconnection - * - * ### Notifications (no response expected): - */ - #include "llviewerprecompiledheaders.h" #include "llscripteditorws.h" #include "llpreviewscript.h" @@ -51,6 +33,7 @@ #include "llerror.h" #include "lluuid.h" #include "llversioninfo.h" +#include "llagent.h" //======================================================================== LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only) @@ -64,7 +47,7 @@ LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(LL LLWebsocketMgr::connection_h handle) { auto connection = std::make_shared(server, handle); - mActiveConnections.insert(connection); + mActiveConnections[connection->getConnectionID()] = connection; // Call setupConnectionMethods to register any global methods setupConnectionMethods(connection); @@ -72,6 +55,29 @@ LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(LL return connection; } +void LLScriptEditorWSServer::onStarted() +{ + LLSyntaxIdLSL& syntax_id_mgr = LLSyntaxIdLSL::instance(); + wptr_t that(std::static_pointer_cast(shared_from_this())); + + mLastSyntaxId = syntax_id_mgr.getSyntaxID(); + mLanguageChangeSignal = syntax_id_mgr.addSyntaxIDCallback( + [that]() + { + auto server = that.lock(); + if (server && server->isRunning()) + { + server->broadcastLangugeChange(); + } + }); +} + +void LLScriptEditorWSServer::onStopped() +{ + mLanguageChangeSignal.disconnect(); + mLastSyntaxId.setNull(); +} + void LLScriptEditorWSServer::onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) { // Call parent class to handle JSON-RPC setup and standard methods @@ -92,35 +98,102 @@ void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnecti auto script_connection = std::dynamic_pointer_cast(connection); if (script_connection) { - mActiveConnections.erase(script_connection); + U32 connection_id = script_connection->getConnectionID(); + unsubscribeConnection(connection_id); + mActiveConnections.erase(connection_id); - LL_INFOS("ScriptEditorWS") << "Removed connection from active connections. Total: " + LL_DEBUGS("ScriptEditorWS") << "Removed connection from active connections. Total: " << mActiveConnections.size() << LL_ENDL; // TODO: When connections reach 0, stop the server aftera a timeout. } } -bool LLScriptEditorWSServer::associateEditor(const LLHandle& editor_handle, const std::string& script_id) +bool LLScriptEditorWSServer::subscribeScriptEditor(const LLHandle& editor_handle, const std::string &script_id) { if (!editor_handle.isDead()) { - mScriptEditors[script_id] = editor_handle; + auto it = mSubscriptions.find(script_id); + if (it == mSubscriptions.end()) + { // Don't readd if already subscribed + mSubscriptions.emplace(script_id, EditorSubscription{ editor_handle, LLScriptEditorWSConnection::wptr_t() }); + return false; + } + else + { // Update existing subscription with new editor handle + it->second.mEditorHandle = editor_handle; + } return true; } return false; } -void LLScriptEditorWSServer::dissociateEditor(const std::string& script_id) +void LLScriptEditorWSServer::unsubscribeEditor(const std::string &script_id) +{ + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end()) + { + mSubscriptions.erase(it); + } +} + +void LLScriptEditorWSServer::unsubscribeConnection(U32 connection_id) +{ + for (auto it = mSubscriptions.begin(); it != mSubscriptions.end(); ) + { + if (it->second.mConnectionID == connection_id) + { + LL_DEBUGS("ScriptEditorWS") << "Unsubscribing script " << it->first + << " from connection ID " << connection_id << LL_ENDL; + it = mSubscriptions.erase(it); + } + else + { + ++it; + } + } +} + +LLScriptEditorWSServer::SubscriptionError_t LLScriptEditorWSServer::updateScriptSubscription(const std::string &script_id, U32 connection_id) { - mScriptEditors.erase(script_id); + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end()) + { + if (it->second.mEditorHandle.isDead()) + { + unsubscribeEditor(script_id); + return SUBSCRIPTION_INVALID_EDITOR; + } + + auto con_it = mActiveConnections.find(connection_id); + if (con_it == mActiveConnections.end()) + { + return SUBSCRIPTION_INTERNAL_ERROR; + } + + if ((it->second.mConnectionID != 0) && !it->second.mConnection.expired() + && it->second.mConnection.lock()->isConnected()) + { + LL_WARNS("ScriptEditorWS") << "Script " << script_id << " is already subscribed on connection ID " << it->second.mConnectionID + << ", cannot subscribe again on connection ID " << connection_id << LL_ENDL; + // In the future we may want to support multiple connections per script. + // That would imply it was open in multiple editors. + return SUBSCRIPTION_ALREADY_SUBSCRIBED; + } + + it->second.mConnectionID = connection_id; + it->second.mConnection = con_it->second; + return SUBSCRIPTION_SUCCESS; + } + return SUBSCRIPTION_INVALID_SUBSCRIPTION; } + LLHandle LLScriptEditorWSServer::findEditorForScript(const std::string& script_id) const { - auto it = mScriptEditors.find(script_id); - if (it != mScriptEditors.end()) + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end()) { - return it->second; + return it->second.mEditorHandle; } return LLHandle(); } @@ -135,9 +208,9 @@ std::shared_ptr LLScriptEditorWSServer::findConnecti std::set LLScriptEditorWSServer::getActiveScripts() const { std::set active_scripts; - for (const auto& [script_id, editor_handle] : mScriptEditors) + for (const auto& [script_id, subinfo] : mSubscriptions) { - if (!editor_handle.isDead()) + if (!subinfo.mEditorHandle.isDead()) { active_scripts.insert(script_id); } @@ -145,69 +218,182 @@ std::set LLScriptEditorWSServer::getActiveScripts() const return active_scripts; } -void LLScriptEditorWSServer::broadcastScriptUpdate(const std::string& script_id, const std::string& content, const LLSD& metadata) +void LLScriptEditorWSServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) { - LL_DEBUGS("ScriptEditorWS") << "Broadcasting script update for script: " << script_id << LL_ENDL; + // Call parent class to register global JSON-RPC methods + LLJSONRPCServer::setupConnectionMethods(connection); - LLSD params; - params["script_id"] = script_id; - params["content"] = content; - params["timestamp"] = LLDate::now().asString(); + // Cast to our specific connection type to access script editor functionality + auto script_connection = std::dynamic_pointer_cast(connection); + if (script_connection) + { + LL_DEBUGS("ScriptEditorWS") << "Setting up script editor connection methods" << LL_ENDL; + wptr_t that(std::static_pointer_cast(shared_from_this())); + + U32 connection_id = script_connection->getConnectionID(); + + script_connection->registerMethod("language.syntax.id", + [that](const std::string&, const LLSD&, const LLSD&) -> LLSD + { + auto server = that.lock(); + if (server) + { + return server->handleLanguageIdRequest(); + } + return LLSD(); + }); + script_connection->registerMethod("language.syntax", + [that](const std::string&, const LLSD&, const LLSD& params) + { + auto server = that.lock(); + if (server) + { + return server->handleSyntaxRequest(params); + } + return LLSD(); + }); + script_connection->registerMethod("script.subscribe", + [that, connection_id](const std::string&, const LLSD&, const LLSD& params) -> LLSD + { + auto server = that.lock(); + if (server) + { + return server->handleScriptSubscribe(connection_id, params); + } + return LLSD(); + }); + script_connection->registerMethod("script.unsubscribe", [](const std::string&, const LLSD&, const LLSD& params) -> LLSD + { // this is a notification, no response expected + return LLSD(); + }); + // script_connection->registerMethod("language.syntax", ) + } +} + +void LLScriptEditorWSServer::broadcastLangugeChange() +{ + LLUUID syntax_id = LLSyntaxIdLSL::instance().getSyntaxID(); - if (!metadata.isUndefined()) + if (syntax_id != mLastSyntaxId) { - params["metadata"] = metadata; + mLastSyntaxId = syntax_id; + LLSD params; + params["id"] = syntax_id; + + if (isRunning()) + { + broadcastNotification("language.syntax.change", params); + } } +} - // Send to all connected editors as a notification - broadcastNotification("script.update", params); +LLSD LLScriptEditorWSServer::handleLanguageIdRequest() const +{ + LLSD response; + + response["id"] = mLastSyntaxId; + return response; } -void LLScriptEditorWSServer::broadcastCompilationResult(const std::string& script_id, bool success, const LLSD& errors) +LLSD LLScriptEditorWSServer::handleSyntaxRequest(const LLSD& params) const { - LL_DEBUGS("ScriptEditorWS") << "Broadcasting compilation result for script: " << script_id - << " (success: " << success << ")" << LL_ENDL; + LLSD response(LLSD::emptyMap()); + std::string category = params["kind"].asString(); - LLSD params; - params["script_id"] = script_id; - params["success"] = success; - params["timestamp"] = LLDate::now().asString(); + response["id"] = mLastSyntaxId; - if (!errors.isUndefined() && errors.isArray()) + if (category == "types.luau") { - params["errors"] = errors; + response["types"] = LLSyntaxLua::instance().getTypesXML(); } + else + { + LLSD syntax = LLSyntaxIdLSL::instance().getKeywordsXML(); + + // TODO: support language definitions and additional modules. - // Send to all connected editors as a notification - broadcastNotification("compilation.result", params); + if (syntax.has(category)) + { + response[category] = syntax[category]; + } + } + return response; } -void LLScriptEditorWSServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) +LLSD LLScriptEditorWSServer::handleScriptSubscribe(U32 connection_id, const LLSD& params) { - // Call parent class to register global JSON-RPC methods - LLJSONRPCServer::setupConnectionMethods(connection); + LLSD response(LLSD::emptyMap()); - // Cast to our specific connection type to access script editor functionality - auto script_connection = std::dynamic_pointer_cast(connection); - if (script_connection) + std::string script_id = params["script_id"].asString(); + std::string script_name = params["script_name"].asString(); + std::string language = params["script_language"].asString(); + + SubscriptionError_t result = updateScriptSubscription(script_id, connection_id); + + response["script_id"] = script_id; + response["success"] = (result == SUBSCRIPTION_SUCCESS); + response["status"] = result; + + LL_WARNS_IF(result != SUBSCRIPTION_SUCCESS, "ScriptEditorWS") + << "Script connect request for script " << script_id << " failed with status " << result << LL_ENDL; + switch (result) { - LL_INFOS("ScriptEditorWS") << "Setting up script editor connection methods" << LL_ENDL; + case SUBSCRIPTION_SUCCESS: + response["message"] = "OK"; + break; + case SUBSCRIPTION_INVALID_EDITOR: + response["message"] = "Invalid editor handle"; + break; + case SUBSCRIPTION_INVALID_SUBSCRIPTION: + response["message"] = "No subscription found for script"; + break; + case SUBSCRIPTION_ALREADY_SUBSCRIBED: + response["message"] = "Script already subscribed"; + break; + case SUBSCRIPTION_INTERNAL_ERROR: + response["message"] = "Internal server error"; + break; + } + + if (result == SUBSCRIPTION_SUCCESS) + { + //TODO: Build an info block for the subscribed script. + //buildScriptSubscriptionInfo(result); + } - // Here derived classes could add script-specific method registrations - // For now, the base LLScriptEditorWSConnection doesn't register any specific methods - // but this provides a hook for future customization + return response; +} + +LLSD LLScriptEditorWSServer::handleScriptUnsubscribe(U32 connection_id, const LLSD& params) +{ + std::string script_id = params["script_id"].asString(); - // Example of how custom methods could be registered: - // script_connection->registerMethod("script.custom", handler); + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end() && (it->second.mConnectionID == connection_id)) + { + unsubscribeEditor(script_id); } + return LLSD(); } -//======================================================================== -LLScriptEdContainer* LLScriptEditorWSConnection::getEditor() const +void LLScriptEditorWSServer::sendUnsubscribeScriptEditor(const std::string& script_id) { - return mEditorPanel.isDead() ? nullptr : dynamic_cast(mEditorPanel.get()); + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end()) + { + auto connection = it->second.mConnection.lock(); + if (connection) + { + LLSD params; + params["script_id"] = script_id; + connection->notify("script.unsubscribe", params); + } + } } +//======================================================================== +U32 LLScriptEditorWSConnection::sNextConnectionID = 1; + std::shared_ptr LLScriptEditorWSConnection::getServer() const { return std::static_pointer_cast(mOwningServer.lock()); @@ -220,20 +406,17 @@ void LLScriptEditorWSConnection::onOpen() LL_INFOS("ScriptEditorWS") << "Script editor JSON-RPC connection opened" << LL_ENDL; - // Generate unique editor session ID - mEditorId = LLUUID::generateNewID().asString(); - mEditorReady = false; - - LL_INFOS("ScriptEditorWS") << "Initialized editor session: " << mEditorId << LL_ENDL; - - // Build hello data according to the protocol specification + // Build hello data LLSD handshake; handshake["server_version"] = "1.0.0"; handshake["protocol_version"] = "1.0"; handshake["viewer_name"] = LLVersionInfo::instance().getChannel(); handshake["viewer_version"] = LLVersionInfo::instance().getVersion(); - // Supported languages array + handshake["agent_id"] = gAgent.getID(); + + // handshake["challenge"] = ... TODO: simple challenge, write to a file and have the client echo it back? + LLSD languages = LLSD::emptyArray(); languages.append("lsl"); languages.append("luau"); @@ -243,14 +426,19 @@ void LLScriptEditorWSConnection::onOpen() LLSD features; features["live_sync"] = true; features["compilation"] = true; - features["syntax_highlight"] = true; handshake["features"] = features; - // Send editor.handshake method call to the client and handle response - call("session.handshake", handshake, [this](const LLSD& result, const LLSD& error) { + wptr_t that = shared_from_this(); + + // Send session.handshake method call and the response + call("session.handshake", handshake, [that](const LLSD& result, const LLSD& error) { if (error.isUndefined()) { - handleHandshakeResponse(result); + auto self = that.lock(); + if (self) + { + self->handleHandshakeResponse(result); + } } else { @@ -266,17 +454,7 @@ void LLScriptEditorWSConnection::onClose() { // Call parent class to clean up JSON-RPC infrastructure LLJSONRPCConnection::onClose(); - - LL_INFOS("ScriptEditorWS") << "Script editor JSON-RPC connection closed for session: " - << mEditorId << LL_ENDL; - - cleanupConnection(); - - // Clean up editor-specific state - mEditorId.clear(); - mEditorCapabilities.clear(); - mScriptId.clear(); - mEditorReady = false; + mOwningServer.reset(); // Clean up handshake response data mClientName.clear(); @@ -297,6 +475,8 @@ void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) mClientVersion = result["client_version"].asString(); mProtocolVersion = result["protocol_version"].asString(); + // TODO: Validate challenge_response if implemented + // Validate protocol compatibility if (mProtocolVersion != "1.0") { @@ -307,7 +487,6 @@ void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) // Store script information if provided mScriptName = result["script_name"].asString(); mScriptLanguage = result["script_language"].asString(); - mScriptId = result["script_id"].asString(); // Store supported languages for (const auto& lang : llsd::inArray( result["languages"])) @@ -326,67 +505,7 @@ void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) } } - connectToEditor(mScriptId); - // Mark editor as ready - mEditorReady = true; - - LL_INFOS("ScriptEditorWS") << "Handshake completed successfully for session: " << mEditorId << LL_ENDL; -} - -bool LLScriptEditorWSConnection::connectToEditor(const std::string& script_id) -{ - LLScriptEditorWSServer::ptr_t server = std::dynamic_pointer_cast(mOwningServer.lock()); - if (!server) - { - LL_WARNS("ScriptEditorWS") << "Cannot connect to editor - server reference lost" << LL_ENDL; - return false; - } - - mEditorPanel = server->findEditorForScript(script_id); - - LLScriptEdContainer* editor_core = getEditor(); - if (!editor_core) - { - LL_INFOS("ScriptEditorWS") << "Could not find editor: " << script_id << LL_ENDL; - // TODO: Disconnect the client if no editor found - return false; - } - - return true; -} - -void LLScriptEditorWSConnection::cleanupConnection() -{ - LL_INFOS("ScriptEditorWS") << "Cleaning up connection for editor session: " << mEditorId << LL_ENDL; - - LLScriptEditorWSServer::ptr_t server = getServer(); - if (server) - { - server->dissociateEditor(mScriptId); - } - - LLScriptEdContainer* editor_core = getEditor(); - - if (editor_core) - { - editor_core->cleanupWebSocket(); - - // Notify the editor panel of disconnection - //editor_core->onExternalEditorDisconnected(); - } - - mEditorPanel = LLHandle(); -} - - -void LLScriptEditorWSConnection::sendDisconnect(S32 reason, const std::string& message) -{ - LL_INFOS("ScriptEditorWS") << "Sending disconnect message to editor (reason: " - << reason << ", message: " << message << ")" << LL_ENDL; - - LLSD params; - params["reason"] = reason; - params["message"] = message; + notify("session.ok"); - notify("session.disconnect", params); + LL_INFOS("ScriptEditorWS") << "Handshake completed successfully." << LL_ENDL; } diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h index 78c675a1f4..f6e40fad6e 100644 --- a/indra/newview/llscripteditorws.h +++ b/indra/newview/llscripteditorws.h @@ -42,44 +42,30 @@ class LLLiveLSLEditor; class LLScriptEdContainer; class LLScriptEditorWSServer; -/** - * @class LLScriptEditorWSConnection - * @brief JSON-RPC WebSocket connection specialized for external script editor communication - * - * This class handles JSON-RPC 2.0 communication between the Second Life viewer - * and external script editors. It provides a clean base for implementing - * script editor integration using the standard JSON-RPC 2.0 protocol. - * - * ## Usage - * - * @code - * // Create server and let base JSON-RPC handle method registration - * auto server = std::make_shared("script_editor_server", 9020); - * - * // Register custom methods as needed - * connection->registerMethod("custom.method", handler); - * @endcode - */ -class LLScriptEditorWSConnection : public LLJSONRPCConnection, - public std::enable_shared_from_this +class LLScriptEditorWSConnection : public LLJSONRPCConnection, public std::enable_shared_from_this { public: + using ptr_t = std::shared_ptr; + using wptr_t = std::weak_ptr; + enum DisconnectReason { - REASON_NORMAL = 0, - REASON_EDITOR_CLOSED = 1, + REASON_NORMAL = 0, + REASON_EDITOR_CLOSED = 1, REASON_PROTOCOL_ERROR = 2, - REASON_TIMEOUT = 3, + REASON_TIMEOUT = 3, REASON_INTERNAL_ERROR = 4 }; - LLScriptEditorWSConnection(const LLWebsocketMgr::WSServer::ptr_t server, - const LLWebsocketMgr::connection_h& handle) - : LLJSONRPCConnection(server, handle) - { } + LLScriptEditorWSConnection(const LLWebsocketMgr::WSServer::ptr_t server, const LLWebsocketMgr::connection_h& handle) : + LLJSONRPCConnection(server, handle) + { + mConnectionID = sNextConnectionID++; + } ~LLScriptEditorWSConnection() override = default; + U32 getConnectionID() const { return mConnectionID; } // Connection lifecycle overrides void onOpen() override; @@ -100,26 +86,21 @@ private: */ void handleHandshakeResponse(const LLSD& result); - bool connectToEditor(const std::string& script_id); - void cleanupConnection(); - - LLScriptEdContainer* getEditor() const; + LLScriptEdContainer* getEditor() const; std::shared_ptr getServer() const; - std::string mEditorId; ///< Unique identifier for this editor session - LLSD mEditorCapabilities; ///< Editor capabilities metadata - std::string mScriptId; ///< Unique identifier for the script being edited - bool mEditorReady; ///< Whether editor has completed initialization - LLHandle mEditorPanel; ///< Handle to the associated LSL editor panel + U32 mConnectionID{ 0 }; ///< Unique identifier for this connection // Client handshake response data - std::string mClientName; ///< Name of the external editor client - std::string mClientVersion; ///< Version of the external editor client - std::string mProtocolVersion; ///< JSON-RPC protocol version supported by client - std::string mScriptName; ///< Name of the script being edited - std::string mScriptLanguage; ///< Programming language of the script (lsl, luau, etc.) - string_set_t mLanguages; ///< Set of supported scripting languages - string_set_t mFeatures; ///< Active client features (live_sync, compilation, etc.) + std::string mClientName; ///< Name of the external editor client + std::string mClientVersion; ///< Version of the external editor client + std::string mProtocolVersion; ///< JSON-RPC protocol version supported by client + std::string mScriptName; ///< Name of the script being edited + std::string mScriptLanguage; ///< Programming language of the script (lsl, luau, etc.) + string_set_t mLanguages; ///< Set of supported scripting languages + string_set_t mFeatures; ///< Active client features (live_sync, compilation, etc.) + + static U32 sNextConnectionID; }; /** @@ -161,21 +142,34 @@ private: class LLScriptEditorWSServer : public LLJSONRPCServer { public: + enum SubscriptionError_t + { + SUBSCRIPTION_SUCCESS = 0, + SUBSCRIPTION_INVALID_EDITOR, + SUBSCRIPTION_INVALID_SUBSCRIPTION, + SUBSCRIPTION_ALREADY_SUBSCRIBED, + SUBSCRIPTION_INTERNAL_ERROR + }; + static constexpr char const* DEFAULT_SERVER_NAME = "script_editor_server"; static constexpr U16 DEFAULT_SERVER_PORT = 9020; using ptr_t = std::shared_ptr; + using wptr_t = std::weak_ptr; LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only = true); virtual ~LLScriptEditorWSServer() = default; - // Server lifecycle callbacks + void onStarted() override; + void onStopped() override; void onConnectionOpened(const LLWebsocketMgr::WSConnection::ptr_t& connection) override; void onConnectionClosed(const LLWebsocketMgr::WSConnection::ptr_t& connection) override; - bool associateEditor(const LLHandle& editor_handle, const std::string& script_id); - void dissociateEditor(const std::string& script_id); + bool subscribeScriptEditor(const LLHandle& editor_handle, const std::string &script_id); + void unsubscribeEditor(const std::string &script_id); + + void sendUnsubscribeScriptEditor(const std::string& script_id); LLHandle findEditorForScript(const std::string& script_id) const; std::shared_ptr findConnectionForScript(const std::string& script_id); @@ -186,45 +180,38 @@ public: */ std::set getActiveScripts() const; - /** - * @brief Send script content to all connected editors for a specific script - * @param script_id The script identifier - * @param content The script content - * @param metadata Optional metadata about the script - */ - void broadcastScriptUpdate(const std::string& script_id, const std::string& content, const LLSD& metadata = LLSD()); - - /** - * @brief Send compilation results to all connected editors for a specific script - * @param script_id The script identifier - * @param success Whether compilation succeeded - * @param errors Array of compilation errors/warnings - */ - void broadcastCompilationResult(const std::string& script_id, bool success, const LLSD& errors = LLSD()); - protected: LLWebsocketMgr::WSConnection::ptr_t connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, LLWebsocketMgr::connection_h handle) override; - /** - * @brief Apply global method handlers to a new connection - * @param connection The connection to configure - * - * Override this method to customize which methods are registered on - * new connections. The base implementation registers all global methods, - * but derived classes can add additional script-specific methods. - */ - virtual void setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) override; + void setupConnectionMethods(LLJSONRPCConnection::ptr_t connection) override; + + void broadcastLangugeChange(); + + LLSD handleLanguageIdRequest() const; + LLSD handleSyntaxRequest(const LLSD ¶ms) const; + LLSD handleScriptSubscribe(U32 connection_id, const LLSD& params); + LLSD handleScriptUnsubscribe(U32 connection_id, const LLSD& params); private: - using map_id_to_editor_t = std::unordered_map>; + struct EditorSubscription + { + LLHandle mEditorHandle; + LLScriptEditorWSConnection::wptr_t mConnection; + U32 mConnectionID{ 0 }; + }; + using subscriptions_t = std::unordered_map; + + SubscriptionError_t updateScriptSubscription(const std::string &script_id, U32 connection_id); + void unsubscribeConnection(U32 connection_id); + + subscriptions_t mSubscriptions; + std::map mActiveConnections; + + boost::signals2::connection mLanguageChangeSignal; + LLUUID mLastSyntaxId; - map_id_to_editor_t mScriptEditors; - std::set> mActiveConnections; - /** - * @brief Connection timeout management - */ LLTimer mCleanupTimer; static constexpr F32 CLEANUP_INTERVAL = 60.0f; // seconds static constexpr F32 CONNECTION_TIMEOUT = 300.0f; // 5 minutes diff --git a/indra/newview/llsyntaxid.cpp b/indra/newview/llsyntaxid.cpp index 1f8766eea2..a891bf945e 100644 --- a/indra/newview/llsyntaxid.cpp +++ b/indra/newview/llsyntaxid.cpp @@ -343,7 +343,7 @@ void LLSyntaxLua::initialize() if (mInitialized) return; loadDefaultKeywordsIntoLLSD(); - + loadLuaTypesIntoLLSD(); mInitialized = true; } @@ -361,3 +361,18 @@ void LLSyntaxLua::loadDefaultKeywordsIntoLLSD() } } } + +void LLSyntaxLua::loadLuaTypesIntoLLSD() +{ + std::string fullFileSpec = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "types_lua_default.llsd"); + llifstream file(fullFileSpec.c_str()); + + if (file.good()) + { + LLSD content; + if (LLSDSerialize::fromXML(content, file) != LLSDParser::PARSE_FAILURE) + { + mTypesXml = content; + } + } +} diff --git a/indra/newview/llsyntaxid.h b/indra/newview/llsyntaxid.h index c24cea1776..51103e3396 100644 --- a/indra/newview/llsyntaxid.h +++ b/indra/newview/llsyntaxid.h @@ -41,11 +41,20 @@ class LLSyntaxIdLSL : public LLSingleton LLSINGLETON(LLSyntaxIdLSL); friend class fetchKeywordsFileResponder; +public: + using syntax_id_changed_signal_t = boost::signals2::signal; + using syntax_id_changed_h = boost::signals2::connection; + + void initialize(); + bool keywordFetchInProgress(); + LLSD getKeywordsXML() const { return mKeywordsXml; }; + LLUUID getSyntaxID() const { return mSyntaxId; } + syntax_id_changed_h addSyntaxIDCallback(const syntax_id_changed_signal_t::slot_type& cb); + private: std::set mInflightFetches; - typedef boost::signals2::signal syntax_id_changed_signal_t; syntax_id_changed_signal_t mSyntaxIDChangedSignal; - boost::signals2::connection mRegionChangedCallback; + syntax_id_changed_h mRegionChangedCallback; bool syntaxIdChanged(); bool isSupportedVersion(const LLSD& content); @@ -67,11 +76,6 @@ private: LLSD mKeywordsXml; bool mInitialized; -public: - void initialize(); - bool keywordFetchInProgress(); - LLSD getKeywordsXML() const { return mKeywordsXml; }; - boost::signals2::connection addSyntaxIDCallback(const syntax_id_changed_signal_t::slot_type& cb); }; @@ -82,11 +86,13 @@ class LLSyntaxLua : public LLSingleton public: void initialize(); LLSD getKeywordsXML() const { return mKeywordsXml; } + LLSD getTypesXML() const { return mTypesXml; } private: void loadDefaultKeywordsIntoLLSD(); - + void loadLuaTypesIntoLLSD(); LLSD mKeywordsXml; + LLSD mTypesXml; bool mInitialized; }; -- cgit v1.3 From 0d7ca7ff2d0880022ec9b28d56ffc7929981b66f Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Wed, 27 Aug 2025 06:41:14 -0700 Subject: Update indra/newview/llscripteditorws.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- indra/newview/llscripteditorws.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index cb67880455..24f7d71b34 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -104,7 +104,7 @@ void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnecti LL_DEBUGS("ScriptEditorWS") << "Removed connection from active connections. Total: " << mActiveConnections.size() << LL_ENDL; - // TODO: When connections reach 0, stop the server aftera a timeout. + // TODO: When connections reach 0, stop the server after a timeout. } } -- cgit v1.3 From e750c58a0e73c9363f649e42a47ad430f65c169b Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Wed, 24 Sep 2025 07:54:29 -0700 Subject: Changes to the message protocol for script.compiled and language requests. --- indra/newview/llpreviewscript.cpp | 20 +++++- indra/newview/llpreviewscript.h | 6 +- indra/newview/llscripteditorws.cpp | 144 +++++++++++++++++++++++++++++++------ indra/newview/llscripteditorws.h | 5 +- 4 files changed, 146 insertions(+), 29 deletions(-) (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp index f17b2aeed1..9aac1742d5 100644 --- a/indra/newview/llpreviewscript.cpp +++ b/indra/newview/llpreviewscript.cpp @@ -1500,8 +1500,6 @@ void LLScriptEdCore::setAssociatedExperience( const LLUUID& experience_id ) mAssociatedExperience = experience_id; } - - void LLLiveLSLEditor::requestExperiences() { if (!getIsModifiable()) @@ -1719,6 +1717,15 @@ void LLScriptEdContainer::unsubscribeScript() } } +void LLScriptEdContainer::sendCompileResults(LLSD& params) +{ + auto server = mWebSocketServer.lock(); + if (server) + { + std::string script_id_hash_str(getUniqueHash()); + server->sendCompileResults(script_id_hash_str, params); + } +} /// --------------------------------------------------------------------------- /// LLPreviewLSL @@ -1957,6 +1964,7 @@ void LLPreviewLSL::finishedLSLUpload(LLUUID itemId, LLSD response) { preview->callbackLSLCompileFailed(response["errors"]); } + preview->sendCompileResults(response); } } @@ -1980,6 +1988,12 @@ bool LLPreviewLSL::failedLSLUpload(LLUUID itemId, LLUUID taskId, LLSD response, LLSD errors; errors.append(LLTrans::getString("UploadFailed") + reason); preview->callbackLSLCompileFailed(errors); + + LLSD message; + message["compiled"] = false; + message["errors"] = errors; + preview->sendCompileResults(message); + return true; } @@ -2514,6 +2528,8 @@ void LLLiveLSLEditor::finishLSLUpload(LLUUID itemId, LLUUID taskId, LLUUID newAs { preview->callbackLSLCompileFailed(response["errors"]); } + response["is_running"] = isRunning; + preview->sendCompileResults(response); } } diff --git a/indra/newview/llpreviewscript.h b/indra/newview/llpreviewscript.h index 8d53c8899c..168ba1e8ad 100644 --- a/indra/newview/llpreviewscript.h +++ b/indra/newview/llpreviewscript.h @@ -105,7 +105,9 @@ public: void initMenu(); void processKeywords(); void processKeywords(bool luau_language); - LLKeywords& getKeywords() { return mEditor->getKeywords(); } + LLScriptEditor* getEditor() const { return mEditor; } + LLKeywords& getKeywords() const { return mEditor->getKeywords(); } + bool isLuauLanguage() const { return mEditor->getIsLuauLanguage(); } void draw() override; bool postBuild() override; @@ -161,7 +163,6 @@ public: void enableSave(bool b) { mEnableSave = b; } bool hasChanged() const; - private: void onBtnDynamicHelp(); void onBtnUndoChanges(); @@ -223,6 +224,7 @@ public: void startWebsocketServer(); void unsubscribeScript(); + void sendCompileResults(LLSD&); LLScriptEdCore* getScriptEdCore() const { return mScriptEd; } diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index 24f7d71b34..9f829f430e 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -34,6 +34,7 @@ #include "lluuid.h" #include "llversioninfo.h" #include "llagent.h" +#include "llregex.h" //======================================================================== LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only) @@ -198,13 +199,6 @@ LLHandle LLScriptEditorWSServer::findEditorForScript(const std::string& return LLHandle(); } -std::shared_ptr LLScriptEditorWSServer::findConnectionForScript(const std::string& script_id) -{ - // TODO: Implement logic to find connection handling a specific script - // This would require tracking which connection is responsible for which script - return nullptr; -} - std::set LLScriptEditorWSServer::getActiveScripts() const { std::set active_scripts; @@ -300,22 +294,28 @@ LLSD LLScriptEditorWSServer::handleSyntaxRequest(const LLSD& params) const LLSD response(LLSD::emptyMap()); std::string category = params["kind"].asString(); - response["id"] = mLastSyntaxId; + if (category.empty()) + { + response["error"] = "No syntax category specified"; + response["success"] = false; + return response; + } - if (category == "types.luau") + response["id"] = mLastSyntaxId; + if (category == "defs.lua") { - response["types"] = LLSyntaxLua::instance().getTypesXML(); + response["defs"] = LLSyntaxLua::instance().getTypesXML(); + response["success"] = true; + } + else if (category == "defs.lsl") + { + response["defs"] = LLSyntaxIdLSL::instance().getKeywordsXML(); + response["success"] = true; } else { - LLSD syntax = LLSyntaxIdLSL::instance().getKeywordsXML(); - - // TODO: support language definitions and additional modules. - - if (syntax.has(category)) - { - response[category] = syntax[category]; - } + response["error"] = "Unknown syntax category requested"; + response["success"] = false; } return response; } @@ -376,7 +376,7 @@ LLSD LLScriptEditorWSServer::handleScriptUnsubscribe(U32 connection_id, const LL return LLSD(); } -void LLScriptEditorWSServer::sendUnsubscribeScriptEditor(const std::string& script_id) +void LLScriptEditorWSServer::notifyScript(const std::string& script_id, const std::string &method, const LLSD& message) const { auto it = mSubscriptions.find(script_id); if (it != mSubscriptions.end()) @@ -384,11 +384,107 @@ void LLScriptEditorWSServer::sendUnsubscribeScriptEditor(const std::string& scri auto connection = it->second.mConnection.lock(); if (connection) { - LLSD params; - params["script_id"] = script_id; - connection->notify("script.unsubscribe", params); + connection->notify(method, message); + } + } +} + + +void LLScriptEditorWSServer::sendUnsubscribeScriptEditor(const std::string& script_id) +{ + LLSD params; + params["script_id"] = script_id; + + notifyScript(script_id, "script.unsubscribe", params); +} + +void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, const LLSD &results) const +{ + LLHandle editor_handle = findEditorForScript(script_id); + if (editor_handle.isDead()) + { + return; + } + LLScriptEdContainer* editor = dynamic_cast(editor_handle.get()); + if (!editor) + { + return; + } + LLScriptEdCore* core = editor->getScriptEdCore(); + bool is_lua = core && (core->isLuauLanguage()); + + LLSD params; + params["scriptId"] = script_id; + params["success"] = results["compiled"].asBoolean(); + params["running"] = results["is_running"].asBoolean(); + if (results.has("errors")) + { + params["errors"] = LLSD::emptyArray(); + + if (is_lua) + { // lua errors: ":line: message", line is 1-based + const static boost::regex lua_err_regex(R"(^[^:]*:(\d+): (.+)$)"); + + for (const auto& err : llsd::inArray(results["errors"])) + { + boost::smatch match; + LLSD err_entry; + + err_entry["column"] = 0; // TODO: Lua compiler does not provide column info + err_entry["level"] = "ERROR"; + + if (boost::regex_match(err.asString(), match, lua_err_regex)) + { + S32 line_number = std::stoi(match[1].str()); + std::string message = match[2].str(); + + err_entry["row"] = line_number; + err_entry["message"] = message; + } + else + { + err_entry["row"] = 0; + err_entry["message"] = err.asString(); + } + params["errors"].append(err_entry); + } + } + else + { // lsl errors: "(line, column) : SEVERITY : message", line and column are 0-based + static const boost::regex lsl_err_regex(R"(\((\d+), (\d+)\) : ([^:]+) : (.+))"); + + for (const auto& err : llsd::inArray(results["errors"])) + { + boost::smatch match; + LLSD err_entry; + + if (boost::regex_match(err.asString(), match, lsl_err_regex)) + { + S32 line_number = std::stoi(match[1].str()); + S32 col_number = std::stoi(match[2].str()); + std::string severity = match[3].str(); + std::string message = match[4].str(); + + err_entry["row"] = line_number + 1; + err_entry["column"] = col_number + 1; + err_entry["level"] = severity; + err_entry["message"] = message; + err_entry["format"] = "lsl"; + } + else + { + err_entry["row"] = 0; + err_entry["column"] = 0; + err_entry["level"] = "ERROR"; + err_entry["message"] = err.asString(); + err_entry["format"] = "lsl"; + } + params["errors"].append(err_entry); + } } } + + notifyScript(script_id, "script.compiled", params); } //======================================================================== @@ -414,13 +510,15 @@ void LLScriptEditorWSConnection::onOpen() handshake["viewer_version"] = LLVersionInfo::instance().getVersion(); handshake["agent_id"] = gAgent.getID(); + handshake["agent_name"] = "todo"; // handshake["challenge"] = ... TODO: simple challenge, write to a file and have the client echo it back? LLSD languages = LLSD::emptyArray(); languages.append("lsl"); languages.append("luau"); - handshake["supported_languages"] = languages; + handshake["languages"] = languages; + handshake["syntax_id"] = LLSyntaxIdLSL::instance().getSyntaxID(); // Features object LLSD features; diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h index f6e40fad6e..7112320c57 100644 --- a/indra/newview/llscripteditorws.h +++ b/indra/newview/llscripteditorws.h @@ -169,10 +169,11 @@ public: bool subscribeScriptEditor(const LLHandle& editor_handle, const std::string &script_id); void unsubscribeEditor(const std::string &script_id); + void notifyScript(const std::string& script_id, const std::string& method, const LLSD& message) const; void sendUnsubscribeScriptEditor(const std::string& script_id); + void sendCompileResults(const std::string& script_id, const LLSD& results) const; - LLHandle findEditorForScript(const std::string& script_id) const; - std::shared_ptr findConnectionForScript(const std::string& script_id); + LLHandle findEditorForScript(const std::string& script_id) const; /** * @brief Get list of active script editing sessions -- cgit v1.3 From 26268f714dc799f94a8e7f3adc66e2d4c1260d65 Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Mon, 29 Sep 2025 15:12:14 -0700 Subject: Implemented simple challenge on handshake, fixed issue with closing a connection. --- indra/newview/llscripteditorws.cpp | 75 +++++++++++++++++++++++++++++++++++++- indra/newview/llscripteditorws.h | 8 ++-- 2 files changed, 76 insertions(+), 7 deletions(-) (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index 9f829f430e..2df4c73cd9 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -134,6 +134,18 @@ void LLScriptEditorWSServer::unsubscribeEditor(const std::string &script_id) if (it != mSubscriptions.end()) { mSubscriptions.erase(it); + S32 connection_id = it->second.mConnectionID; + ptrdiff_t count = std::count_if(mSubscriptions.begin(), mSubscriptions.end(), [connection_id](const auto& pair) { + return pair.second.mConnectionID == connection_id; + }); + auto connection = it->second.mConnection.lock(); + if (connection && !count) + { // We have removed the last subscription, close the connection + LL_DEBUGS("ScriptEditorWS") << "Closing connection ID " << it->second.mConnectionID << + " as last subscription was removed" << LL_ENDL; + connection->sendDisconnect(LLScriptEditorWSConnection::REASON_EDITOR_CLOSED, "Editor closed"); + } + } } @@ -512,7 +524,11 @@ void LLScriptEditorWSConnection::onOpen() handshake["agent_id"] = gAgent.getID(); handshake["agent_name"] = "todo"; - // handshake["challenge"] = ... TODO: simple challenge, write to a file and have the client echo it back? + std::string challenge_file = generateChallenge(); + if (!challenge_file.empty()) + { + handshake["challenge"] = challenge_file; + } LLSD languages = LLSD::emptyArray(); languages.append("lsl"); @@ -564,6 +580,16 @@ void LLScriptEditorWSConnection::onClose() mFeatures.clear(); } +void LLScriptEditorWSConnection::sendDisconnect(S32 reason, const std::string& message) +{ + LL_INFOS("ScriptEditorWS") << "Sending disconnect to client: " << message << LL_ENDL; + LLSD params; + params["reason"] = reason; + params["message"] = message; + notify("session.disconnect", params); + closeConnection(1000, message); +} + void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) { LL_INFOS("ScriptEditorWS") << "Processing handshake response from client" << LL_ENDL; @@ -573,7 +599,23 @@ void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) mClientVersion = result["client_version"].asString(); mProtocolVersion = result["protocol_version"].asString(); - // TODO: Validate challenge_response if implemented + if (mChallenge.notNull()) + { + // Validate challenge response + bool valid_response = (result.has("challenge_response") && + (result["challenge_response"].asUUID() == mChallenge)); + + LLFile::remove(mChallengeFile); + mChallengeFile.clear(); + mChallenge.setNull(); + if (!valid_response) + { + LL_WARNS("ScriptEditorWS") << "Invalid or missing challenge response from client" << LL_ENDL; + sendDisconnect(REASON_PROTOCOL_ERROR, "Invalid challenge response"); + return; + } + } + LLUUID challenge_response = result["challenge_response"].asUUID(); // Validate protocol compatibility if (mProtocolVersion != "1.0") @@ -603,7 +645,36 @@ void LLScriptEditorWSConnection::handleHandshakeResponse(const LLSD& result) } } + if (mChallenge.notNull()) + { + // Remove temporary challenge file + LLFile::remove(mChallengeFile); + mChallenge.setNull(); + mChallengeFile.clear(); + } + notify("session.ok"); LL_INFOS("ScriptEditorWS") << "Handshake completed successfully." << LL_ENDL; } + +std::string LLScriptEditorWSConnection::generateChallenge() +{ + mChallenge.generate(); + + mChallengeFile = std::string(LLFile::tmpdir()) + "sl_script_challenge.tmp"; + + llofstream file(mChallengeFile.c_str()); + if (!file.is_open()) + { + LL_WARNS() << "Unable to open challenge file: " << mChallengeFile << LL_ENDL; + mChallenge.setNull(); + mChallengeFile.clear(); + return std::string(); + } + + file << mChallenge; + file.close(); + + return mChallengeFile; +} diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h index 7112320c57..2c3ae31e8d 100644 --- a/indra/newview/llscripteditorws.h +++ b/indra/newview/llscripteditorws.h @@ -71,11 +71,6 @@ public: void onOpen() override; void onClose() override; - /** - * @brief Send session disconnect message to the external editor - * @param reason Numeric reason code for the disconnect (default 0 for normal closure) - * @param message Human-readable disconnect message (default "Goodbye") - */ void sendDisconnect(S32 reason = 0, const std::string& message = "Goodbye"); private: @@ -85,6 +80,7 @@ private: * @param result The response data from the client containing client information */ void handleHandshakeResponse(const LLSD& result); + std::string generateChallenge(); LLScriptEdContainer* getEditor() const; std::shared_ptr getServer() const; @@ -99,6 +95,8 @@ private: std::string mScriptLanguage; ///< Programming language of the script (lsl, luau, etc.) string_set_t mLanguages; ///< Set of supported scripting languages string_set_t mFeatures; ///< Active client features (live_sync, compilation, etc.) + LLUUID mChallenge; + std::string mChallengeFile; ///< Temporary file used for challenge-response verification static U32 sNextConnectionID; }; -- cgit v1.3 From 339e7ccae99aab39a01aef052719ab9b3432919b Mon Sep 17 00:00:00 2001 From: Rider Linden Date: Wed, 1 Oct 2025 15:30:40 -0700 Subject: Added scripting options floater for config, switched to using config values. Added "runtime.debug" and "runtime.error" notifications. --- indra/newview/CMakeLists.txt | 2 + indra/newview/app_settings/settings.xml | 44 ++++++ indra/newview/llfloaterimnearbychathandler.cpp | 11 ++ indra/newview/llfloaterpreference.cpp | 6 + indra/newview/llfloaterpreference.h | 1 + indra/newview/llfloaterscripting.cpp | 106 ++++++++++++++ indra/newview/llfloaterscripting.h | 49 +++++++ indra/newview/llpreviewscript.cpp | 19 ++- indra/newview/llscripteditorws.cpp | 162 ++++++++++++++++++++- indra/newview/llscripteditorws.h | 26 +++- indra/newview/llviewerfloaterreg.cpp | 2 + .../default/xui/en/floater_scripting_settings.xml | 143 ++++++++++++++++++ .../default/xui/en/panel_preferences_advanced.xml | 51 ++----- 13 files changed, 561 insertions(+), 61 deletions(-) create mode 100644 indra/newview/llfloaterscripting.cpp create mode 100644 indra/newview/llfloaterscripting.h create mode 100644 indra/newview/skins/default/xui/en/floater_scripting_settings.xml (limited to 'indra/newview/llscripteditorws.cpp') diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 6c7b4fef81..702a738e57 100644 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -291,6 +291,7 @@ set(viewer_SOURCE_FILES llfloatersceneloadstats.cpp llfloaterscriptdebug.cpp llfloaterscriptedprefs.cpp + llfloaterscripting.cpp llfloaterscriptlimits.cpp llfloatersearch.cpp llfloatersellland.cpp @@ -971,6 +972,7 @@ set(viewer_HEADER_FILES llfloatersceneloadstats.h llfloaterscriptdebug.h llfloaterscriptedprefs.h + llfloaterscripting.h llfloaterscriptlimits.h llfloatersearch.h llfloatersellland.h diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index 8d2e077f0b..3f4800ac91 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -13915,6 +13915,50 @@ Value + ExternalWebsocketSyncEnable + + Comment + Enables the Websocket JSONRPC server when doing external script editing. + Persist + 1 + Type + Boolean + Value + 1 + + ExternalWebsocketSyncPort + + Comment + Port that the JSONRPC server listens on when editing + Persist + 1 + Type + S32 + Value + 9020 + + ExternalWebsocketSyncLocal + + Comment + Should the JSONRPC server listen only for local connections. + Persist + 1 + Type + Boolean + Value + 1 + + ExternalWebsocketForwardDebug + + Comment + Forward messages and runtime errors for a script to JSONRPC client. + Persist + 1 + Type + Boolean + Value + 1 + YawFromMousePosition Comment diff --git a/indra/newview/llfloaterimnearbychathandler.cpp b/indra/newview/llfloaterimnearbychathandler.cpp index c920a3c898..1e3bc2804e 100644 --- a/indra/newview/llfloaterimnearbychathandler.cpp +++ b/indra/newview/llfloaterimnearbychathandler.cpp @@ -44,6 +44,7 @@ #include "llfloaterimcontainer.h" #include "llrootview.h" #include "lllayoutstack.h" +#include "llscripteditorws.h" //add LLFloaterIMNearbyChatHandler to LLNotificationsUI namespace using namespace LLNotificationsUI; @@ -335,6 +336,7 @@ void LLFloaterIMNearbyChatScreenChannel::addChat(LLSD& chat) { if (!gSavedSettings.getBOOL("ShowScriptErrors")) return; + if (gSavedSettings.getS32("ShowScriptErrorsLocation") == 1) return; } @@ -526,6 +528,15 @@ void LLFloaterIMNearbyChatHandler::processChat(const LLChat& chat_msg, if (!gSavedSettings.getBOOL("ShowScriptErrors")) return; + if (gSavedSettings.getBOOL("ExternalWebsocketSyncEnable") && gSavedSettings.getBOOL("ExternalWebsocketForwardDebug")) + { + LLScriptEditorWSServer::ptr_t server = LLScriptEditorWSServer::getServer(); + if (server) + { + server->forwardChatToIDE(chat_msg); + } + } + // don't process debug messages from not owned objects, see EXT-7762 if (gAgentID != chat_msg.mOwnerID) { diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp index 291f22d78f..1f13a2f933 100644 --- a/indra/newview/llfloaterpreference.cpp +++ b/indra/newview/llfloaterpreference.cpp @@ -346,6 +346,7 @@ LLFloaterPreference::LLFloaterPreference(const LLSD& key) mCommitCallbackRegistrar.add("Pref.RememberedUsernames", boost::bind(&LLFloaterPreference::onClickRememberedUsernames, this)); mCommitCallbackRegistrar.add("Pref.SpellChecker", boost::bind(&LLFloaterPreference::onClickSpellChecker, this)); mCommitCallbackRegistrar.add("Pref.Advanced", boost::bind(&LLFloaterPreference::onClickAdvanced, this)); + mCommitCallbackRegistrar.add("Pref.Scripting", boost::bind(&LLFloaterPreference::onClickScriptingPerfs, this)); sSkin = gSavedSettings.getString("SkinCurrent"); @@ -1825,6 +1826,11 @@ void LLFloaterPreference::onClickAdvanced() } } +void LLFloaterPreference::onClickScriptingPerfs() +{ + LLFloaterReg::showInstance("scripting_settings"); +} + void LLFloaterPreference::onClickActionChange() { updateClickActionControls(); diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h index a784d502ef..73abe49d22 100644 --- a/indra/newview/llfloaterpreference.h +++ b/indra/newview/llfloaterpreference.h @@ -190,6 +190,7 @@ public: void onClickRenderExceptions(); void onClickAutoAdjustments(); void onClickAdvanced(); + void onClickScriptingPerfs(); void applyUIColor(LLUICtrl* ctrl, const LLSD& param); void getUIColor(LLUICtrl* ctrl, const LLSD& param); void onLogChatHistorySaved(); diff --git a/indra/newview/llfloaterscripting.cpp b/indra/newview/llfloaterscripting.cpp new file mode 100644 index 0000000000..0719ced58d --- /dev/null +++ b/indra/newview/llfloaterscripting.cpp @@ -0,0 +1,106 @@ +/** + * @file llfloaterscripting.cpp + * @brief Asset creation permission preferences. + * @author Jonathan Yap + * + * $LicenseInfo:firstyear=2001&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2025, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#include "llviewerprecompiledheaders.h" +#include "llcheckboxctrl.h" +#include "llfloaterscripting.h" +#include "llviewercontrol.h" +#include "llviewerwindow.h" +#include "lluictrlfactory.h" +#include "llpermissions.h" +#include "llagent.h" +#include "llviewerregion.h" +#include "llnotificationsutil.h" +#include "llsdserialize.h" +#include "llvoavatar.h" +#include "llcorehttputil.h" +#include "lleventfilter.h" +#include "lleventcoro.h" +#include "llviewermenufile.h" +#include "llappviewer.h" + +namespace +{ + class LLEditorPicker : public LLFilePickerThread + { + public: + LLEditorPicker(LLFloaterScripting *floater): + LLFilePickerThread(LLFilePicker::FFLOAD_EXE) + { + mHandle = floater->getDerivedHandle(); + } + void notify(const std::vector& filenames) override + { + if (LLAppViewer::instance()->quitRequested()) + { + return; + } + + LLFloaterScripting* floater = mHandle.get(); + if (floater && !filenames.empty()) + { + floater->pickedEditor(filenames.front()); + } + } + + private: + LLHandle mHandle; + }; + +} + +LLFloaterScripting::LLFloaterScripting(const LLSD& seed) + : LLFloater(seed) +{ + mCommitCallbackRegistrar.add("ScriptingSettings.CLOSE", boost::bind(&LLFloaterScripting::onClickClose, this)); + mCommitCallbackRegistrar.add("ScriptingSettings.BROWSE", boost::bind(&LLFloaterScripting::onClickBrowse, this)); +} + +bool LLFloaterScripting::postBuild() +{ + refresh(); + return true; +} + +void LLFloaterScripting::onClickClose() +{ + closeFloater(); +} + +void LLFloaterScripting::onClickBrowse() +{ + (new LLEditorPicker(this))->getFile(); +} + +void LLFloaterScripting::pickedEditor(std::string_view editor) +{ + assert_main_thread(); + std::stringstream cmdline; + cmdline << "\"" << editor << "\" \"%s\""; + + gSavedSettings.setString("ExternalEditor", cmdline.str()); +} diff --git a/indra/newview/llfloaterscripting.h b/indra/newview/llfloaterscripting.h new file mode 100644 index 0000000000..ca7bd3e091 --- /dev/null +++ b/indra/newview/llfloaterscripting.h @@ -0,0 +1,49 @@ +/** + * @file llfloaterscripting.h + * @brief Asset creation permission preferences. + * @author Jonathan Yap + * + * $LicenseInfo:firstyear=2002&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2025, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#pragma once + +#include "llfloater.h" +#include "lleventcoro.h" +#include "llcoros.h" + +class LLFloaterScripting : public LLFloater +{ + friend class LLFloaterReg; + +public: + bool postBuild() override; + void onClickClose(); + void onClickBrowse(); + + void pickedEditor(std::string_view editor); + +private: + LLFloaterScripting(const LLSD& seed); + +}; + diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp index 9aac1742d5..bd1f68da33 100644 --- a/indra/newview/llpreviewscript.cpp +++ b/indra/newview/llpreviewscript.cpp @@ -1671,27 +1671,26 @@ bool LLScriptEdContainer::handleKeyHere(KEY key, MASK mask) void LLScriptEdContainer::startWebsocketServer() { - // if the user has enabled websockets, create the server to talk to the external editor + if (gSavedSettings.getBOOL("ExternalWebsocketSyncEnable")) { - // TODO: Get the name, port, and locality from settings - std::string server_name(LLScriptEditorWSServer::DEFAULT_SERVER_NAME); - U16 server_port(LLScriptEditorWSServer::DEFAULT_SERVER_PORT); - bool server_localhost(true); - // Attempt to find an existing server LLWebsocketMgr& wsmgr = LLWebsocketMgr::instance(); - LLScriptEditorWSServer::ptr_t server = std::static_pointer_cast(wsmgr.findServerByName(server_name)); + LLScriptEditorWSServer::ptr_t server = + std::static_pointer_cast( + wsmgr.findServerByName(LLScriptEditorWSServer::DEFAULT_SERVER_NAME)); if (!server) { // We couldn't find one, so create it - server = std::make_shared(server_name, server_port, server_localhost); + U16 server_port = static_cast(gSavedSettings.getS32("ExternalWebsocketSyncPort")); + bool server_localhost = gSavedSettings.getBOOL("ExternalWebsocketSyncLocal"); + server = std::make_shared(LLScriptEditorWSServer::DEFAULT_SERVER_NAME, server_port, server_localhost); wsmgr.addServer(server); } bool is_running = server->isRunning(); if (!is_running) { // Server isn't running, so start it - is_running = wsmgr.startServer(server_name); + is_running = wsmgr.startServer(LLScriptEditorWSServer::DEFAULT_SERVER_NAME); } if (!is_running && !server->isRunning()) @@ -1701,7 +1700,7 @@ void LLScriptEdContainer::startWebsocketServer() } std::string script_id_hash_str(getUniqueHash()); - server->subscribeScriptEditor(getHandle(), script_id_hash_str); + server->subscribeScriptEditor(mObjectUUID, mItemUUID, mScriptEd->mScriptName, getHandle(), script_id_hash_str); mWebSocketServer = server; } } diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp index 2df4c73cd9..72aaf919ea 100644 --- a/indra/newview/llscripteditorws.cpp +++ b/indra/newview/llscripteditorws.cpp @@ -35,6 +35,9 @@ #include "llversioninfo.h" #include "llagent.h" #include "llregex.h" +#include "llviewerobject.h" +#include "llviewerobjectlist.h" +#include "llchat.h" //======================================================================== LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only) @@ -44,6 +47,18 @@ LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port << " on port " << port << LL_ENDL; } +LLScriptEditorWSServer::ptr_t LLScriptEditorWSServer::getServer() +{ + if (!LLWebsocketMgr::instanceExists()) + { + return nullptr; + } + LLWebsocketMgr& wsmgr = LLWebsocketMgr::instance(); + return std::static_pointer_cast( + wsmgr.findServerByName(LLScriptEditorWSServer::DEFAULT_SERVER_NAME)); +} + + LLWebsocketMgr::WSConnection::ptr_t LLScriptEditorWSServer::connectionFactory(LLWebsocketMgr::WSServer::ptr_t server, LLWebsocketMgr::connection_h handle) { @@ -109,14 +124,16 @@ void LLScriptEditorWSServer::onConnectionClosed(const LLWebsocketMgr::WSConnecti } } -bool LLScriptEditorWSServer::subscribeScriptEditor(const LLHandle& editor_handle, const std::string &script_id) +bool LLScriptEditorWSServer::subscribeScriptEditor(const LLUUID& object_id, const LLUUID& item_id, std::string_view script_name, + const LLHandle& editor_handle, const std::string& script_id) { if (!editor_handle.isDead()) { auto it = mSubscriptions.find(script_id); if (it == mSubscriptions.end()) - { // Don't readd if already subscribed - mSubscriptions.emplace(script_id, EditorSubscription{ editor_handle, LLScriptEditorWSConnection::wptr_t() }); + { // Don't re-add if already subscribed + mSubscriptions.emplace(script_id, + LLScriptEditorWSServer::EditorSubscription(object_id, item_id, script_name, editor_handle)); return false; } else @@ -369,8 +386,14 @@ LLSD LLScriptEditorWSServer::handleScriptSubscribe(U32 connection_id, const LLSD if (result == SUBSCRIPTION_SUCCESS) { - //TODO: Build an info block for the subscribed script. - //buildScriptSubscriptionInfo(result); + auto it = mSubscriptions.find(script_id); + if (it != mSubscriptions.end()) + { + LLViewerObject* object = gObjectList.findObject((*it).second.mObjectID); + response["object_id"] = (*it).second.mObjectID; + //response["object_name"] = object ? object->getName() : "Unknown"; + response["item_id"] = (*it).second.mItemID; + } } return response; @@ -499,6 +522,133 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co notifyScript(script_id, "script.compiled", params); } +void LLScriptEditorWSServer::forwardChatToIDE(const LLChat& chat_msg) const +{ + auto it = std::find_if(mSubscriptions.begin(), mSubscriptions.end(), + [&chat_msg](const auto& pair) { return (pair.second.mObjectID == chat_msg.mFromID); }); + + if (it == mSubscriptions.end()) + { // Not a script we are tracking + return; + } + + bool is_error = false; + std::string error_message; + std::string object_name; + std::string script_name; + S32 line_number = 0; + // We have at least one script from this object, we will forward the message to the IDE + // but first we need to see if it is a runtime error + std::vector lines = LLStringUtil::getTokens(chat_msg.mText, "\n"); + // If this is a runtime error, the first line will look like: " [script: