@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/godot-integration/GodotLiveLink.js

@@ -0,0 +1,962 @@
+'use strict';
+
+/**
+ * @file GodotLiveLink.ts
+ * @description Godot Engine Live Link for Nice2Dev Game Engine
+ * PRO-1.9.2: Godot Live Link
+ *
+ * Features:
+ * - Godot Editor Plugin (GDScript)
+ * - Scene tree synchronization
+ * - Debug protocol integration
+ * - Remote scene editing
+ * - Live game viewport
+ */
+// ============================================================
+// Godot Live Link Client
+// ============================================================
+class GodotLiveLinkClient {
+    constructor(config) {
+        this.callbacks = {};
+        this.ws = null;
+        this.heartbeatTimer = null;
+        this.reconnectTimer = null;
+        this.config = {
+            url: 'ws://localhost:6006',
+            autoReconnect: true,
+            reconnectInterval: 3000,
+            maxReconnectAttempts: 10,
+            heartbeatInterval: 10000,
+            clientId: `nice2dev-${Date.now()}`,
+            enableDebug: true,
+            ...config,
+        };
+        this.state = {
+            isConnected: false,
+            isReconnecting: false,
+            reconnectAttempts: 0,
+            selectedNodes: [],
+            playState: {
+                isPlaying: false,
+                isPaused: false,
+                isDebugging: false,
+            },
+            breakpoints: new Map(),
+        };
+    }
+    // ─── Connection ────────────────────────────────────────
+    connect() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        try {
+            this.ws = new WebSocket(this.config.url);
+            this.ws.onopen = () => {
+                this.state.isConnected = true;
+                this.state.isReconnecting = false;
+                this.state.reconnectAttempts = 0;
+                this.startHeartbeat();
+                this.sendHandshake();
+            };
+            this.ws.onclose = (event) => {
+                this.state.isConnected = false;
+                this.stopHeartbeat();
+                this.callbacks.onDisconnected?.(event.reason);
+                if (this.config.autoReconnect &&
+                    this.state.reconnectAttempts < this.config.maxReconnectAttempts) {
+                    this.scheduleReconnect();
+                }
+            };
+            this.ws.onerror = (event) => {
+                this.callbacks.onError?.(new Error('WebSocket error'));
+            };
+            this.ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+        }
+        catch (error) {
+            this.callbacks.onError?.(error);
+        }
+    }
+    disconnect() {
+        this.config.autoReconnect = false;
+        this.stopHeartbeat();
+        this.clearReconnect();
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.state.isConnected = false;
+    }
+    scheduleReconnect() {
+        this.state.isReconnecting = true;
+        this.state.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, this.config.reconnectInterval);
+    }
+    clearReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.state.isReconnecting = false;
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.send({ type: 'ping', timestamp: Date.now(), payload: null });
+        }, this.config.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // ─── Message Handling ──────────────────────────────────
+    sendHandshake() {
+        this.send({
+            type: 'handshake',
+            timestamp: Date.now(),
+            payload: {
+                version: '1.0.0',
+                clientId: this.config.clientId,
+                clientType: 'nice2dev',
+                capabilities: {
+                    liveEdit: true,
+                    remoteDebug: this.config.enableDebug,
+                    profiler: true,
+                },
+            },
+        });
+    }
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            switch (message.type) {
+                case 'handshake_ack':
+                    this.state.editorInfo = message.payload;
+                    this.callbacks.onConnected?.(this.state.editorInfo);
+                    this.requestSceneTree();
+                    break;
+                case 'scene_tree':
+                    this.state.currentSceneTree = message.payload;
+                    this.callbacks.onSceneTree?.(this.state.currentSceneTree);
+                    break;
+                case 'node_selected':
+                    const selection = message.payload;
+                    this.state.selectedNodes = selection.paths;
+                    this.callbacks.onNodeSelected?.(selection);
+                    break;
+                case 'node_property_changed':
+                    this.callbacks.onNodePropertyChanged?.(message.payload);
+                    break;
+                case 'node_added':
+                    this.callbacks.onNodeAdded?.(message.payload);
+                    break;
+                case 'node_removed':
+                    this.callbacks.onNodeRemoved?.(message.payload);
+                    break;
+                case 'play_state_changed':
+                    this.state.playState = message.payload;
+                    this.callbacks.onPlayStateChanged?.(this.state.playState);
+                    break;
+                case 'breakpoint_hit':
+                    this.callbacks.onBreakpointHit?.(message.payload);
+                    break;
+                case 'console_output':
+                    this.callbacks.onConsoleOutput?.(message.payload);
+                    break;
+                case 'pong':
+                    // Heartbeat response received
+                    break;
+                case 'error':
+                    this.callbacks.onError?.(new Error(message.payload.message));
+                    break;
+            }
+        }
+        catch (error) {
+            this.callbacks.onError?.(error);
+        }
+    }
+    // ─── Scene Tree Operations ─────────────────────────────
+    requestSceneTree() {
+        this.send({
+            type: 'scene_tree',
+            timestamp: Date.now(),
+            payload: { request: true },
+        });
+    }
+    selectNode(nodePath) {
+        this.send({
+            type: 'node_selected',
+            timestamp: Date.now(),
+            payload: { paths: [nodePath] },
+        });
+    }
+    selectNodes(nodePaths) {
+        this.send({
+            type: 'node_selected',
+            timestamp: Date.now(),
+            payload: { paths: nodePaths },
+        });
+    }
+    setNodeProperty(nodePath, property, value) {
+        this.send({
+            type: 'node_property_changed',
+            timestamp: Date.now(),
+            payload: {
+                nodePath,
+                property,
+                value,
+            },
+        });
+    }
+    addNode(parentPath, nodeType, name) {
+        this.send({
+            type: 'node_added',
+            timestamp: Date.now(),
+            payload: {
+                parentPath,
+                nodeType,
+                name,
+            },
+        });
+    }
+    removeNode(nodePath) {
+        this.send({
+            type: 'node_removed',
+            timestamp: Date.now(),
+            payload: { nodePath },
+        });
+    }
+    reparentNode(nodePath, newParentPath, index) {
+        this.send({
+            type: 'node_reparented',
+            timestamp: Date.now(),
+            payload: {
+                nodePath,
+                newParentPath,
+                index,
+            },
+        });
+    }
+    duplicateNode(nodePath) {
+        this.send({
+            type: 'node_added',
+            timestamp: Date.now(),
+            payload: {
+                duplicate: nodePath,
+            },
+        });
+    }
+    // ─── Play Mode Control ─────────────────────────────────
+    play() {
+        this.send({
+            type: 'play_state_changed',
+            timestamp: Date.now(),
+            payload: { action: 'play' },
+        });
+    }
+    pause() {
+        this.send({
+            type: 'play_state_changed',
+            timestamp: Date.now(),
+            payload: { action: 'pause' },
+        });
+    }
+    stop() {
+        this.send({
+            type: 'play_state_changed',
+            timestamp: Date.now(),
+            payload: { action: 'stop' },
+        });
+    }
+    stepFrame() {
+        this.send({
+            type: 'play_state_changed',
+            timestamp: Date.now(),
+            payload: { action: 'step' },
+        });
+    }
+    // ─── Debug Operations ──────────────────────────────────
+    setBreakpoint(scriptPath, line) {
+        const breakpoints = this.state.breakpoints.get(scriptPath) ?? [];
+        if (!breakpoints.includes(line)) {
+            breakpoints.push(line);
+            this.state.breakpoints.set(scriptPath, breakpoints);
+        }
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: {
+                action: 'set',
+                scriptPath,
+                line,
+            },
+        });
+    }
+    removeBreakpoint(scriptPath, line) {
+        const breakpoints = this.state.breakpoints.get(scriptPath) ?? [];
+        const index = breakpoints.indexOf(line);
+        if (index !== -1) {
+            breakpoints.splice(index, 1);
+            this.state.breakpoints.set(scriptPath, breakpoints);
+        }
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: {
+                action: 'remove',
+                scriptPath,
+                line,
+            },
+        });
+    }
+    clearBreakpoints(scriptPath) {
+        if (scriptPath) {
+            this.state.breakpoints.delete(scriptPath);
+        }
+        else {
+            this.state.breakpoints.clear();
+        }
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: {
+                action: 'clear',
+                scriptPath,
+            },
+        });
+    }
+    continueExecution() {
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: { action: 'continue' },
+        });
+    }
+    stepInto() {
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: { action: 'step_into' },
+        });
+    }
+    stepOver() {
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: { action: 'step_over' },
+        });
+    }
+    stepOut() {
+        this.send({
+            type: 'breakpoint_hit',
+            timestamp: Date.now(),
+            payload: { action: 'step_out' },
+        });
+    }
+    getVariableValue(frameId, variable) {
+        this.send({
+            type: 'variable_value',
+            timestamp: Date.now(),
+            payload: {
+                frameId,
+                variable,
+            },
+        });
+    }
+    evaluateExpression(expression, frameId) {
+        this.send({
+            type: 'variable_value',
+            timestamp: Date.now(),
+            payload: {
+                evaluate: expression,
+                frameId,
+            },
+        });
+    }
+    // ─── State Access ──────────────────────────────────────
+    getState() {
+        return { ...this.state };
+    }
+    isConnected() {
+        return this.state.isConnected;
+    }
+    getCurrentSceneTree() {
+        return this.state.currentSceneTree;
+    }
+    getSelectedNodes() {
+        return [...this.state.selectedNodes];
+    }
+    getPlayState() {
+        return { ...this.state.playState };
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Godot Editor Plugin Generator
+// ============================================================
+/**
+ * Generates GDScript code for the Nice2Dev Live Link Godot editor plugin
+ */
+function generateGodotLiveLinkPlugin() {
+    const mainPlugin = `@tool
+extends EditorPlugin
+
+const Nice2DevDock = preload("res://addons/nice2dev_live_link/dock.gd")
+const Nice2DevServer = preload("res://addons/nice2dev_live_link/server.gd")
+
+var dock_instance: Control
+var server_instance: Nice2DevServer
+
+
+func _enter_tree() -> void:
+	# Create the dock
+	dock_instance = Nice2DevDock.new()
+	add_control_to_dock(DOCK_SLOT_RIGHT_UL, dock_instance)
+	
+	# Create the WebSocket server
+	server_instance = Nice2DevServer.new()
+	add_child(server_instance)
+	
+	# Connect signals
+	dock_instance.connect_requested.connect(_on_connect_requested)
+	dock_instance.disconnect_requested.connect(_on_disconnect_requested)
+	
+	# Connect to editor signals
+	var selection := get_editor_interface().get_selection()
+	selection.selection_changed.connect(_on_selection_changed)
+	
+	# Scene changes
+	get_editor_interface().get_resource_filesystem().filesystem_changed.connect(_on_filesystem_changed)
+
+
+func _exit_tree() -> void:
+	if dock_instance:
+		remove_control_from_docks(dock_instance)
+		dock_instance.queue_free()
+	
+	if server_instance:
+		server_instance.stop()
+		server_instance.queue_free()
+
+
+func _on_connect_requested(port: int) -> void:
+	server_instance.start(port)
+	dock_instance.set_connected(true)
+
+
+func _on_disconnect_requested() -> void:
+	server_instance.stop()
+	dock_instance.set_connected(false)
+
+
+func _on_selection_changed() -> void:
+	var selection := get_editor_interface().get_selection()
+	var selected_nodes := selection.get_selected_nodes()
+	var paths: Array[String] = []
+	var ids: Array[int] = []
+	
+	for node in selected_nodes:
+		paths.append(str(node.get_path()))
+		ids.append(node.get_instance_id())
+	
+	server_instance.send_selection(paths, ids)
+
+
+func _on_filesystem_changed() -> void:
+	# Notify Nice2Dev of file changes
+	server_instance.send_filesystem_changed()
+
+
+func get_scene_tree_data() -> Dictionary:
+	var root := get_editor_interface().get_edited_scene_root()
+	if not root:
+		return {}
+	
+	return {
+		"rootPath": str(root.get_path()),
+		"nodes": _serialize_node(root),
+		"editedScenePath": root.scene_file_path
+	}
+
+
+func _serialize_node(node: Node) -> Dictionary:
+	var data := {
+		"id": node.get_instance_id(),
+		"name": node.name,
+		"type": node.get_class(),
+		"path": str(node.get_path()),
+		"groups": node.get_groups(),
+		"children": [],
+		"isEditable": node.owner == get_editor_interface().get_edited_scene_root() or node == get_editor_interface().get_edited_scene_root()
+	}
+	
+	if node.get_parent():
+		data["parentId"] = node.get_parent().get_instance_id()
+	
+	if not node.scene_file_path.is_empty() and node != get_editor_interface().get_edited_scene_root():
+		data["instancePath"] = node.scene_file_path
+	
+	var script := node.get_script()
+	if script:
+		data["script"] = script.resource_path
+	
+	for child in node.get_children():
+		data["children"].append(_serialize_node(child))
+	
+	return data
+`;
+    const dockScript = `@tool
+extends Control
+
+signal connect_requested(port: int)
+signal disconnect_requested
+
+var is_connected := false
+
+
+func _ready() -> void:
+	# Build UI
+	var vbox := VBoxContainer.new()
+	add_child(vbox)
+	vbox.set_anchors_preset(Control.PRESET_FULL_RECT)
+	
+	# Title
+	var title := Label.new()
+	title.text = "Nice2Dev Live Link"
+	title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	vbox.add_child(title)
+	
+	# Separator
+	vbox.add_child(HSeparator.new())
+	
+	# Port input
+	var port_hbox := HBoxContainer.new()
+	vbox.add_child(port_hbox)
+	
+	var port_label := Label.new()
+	port_label.text = "Port:"
+	port_hbox.add_child(port_label)
+	
+	var port_input := SpinBox.new()
+	port_input.name = "PortInput"
+	port_input.min_value = 1024
+	port_input.max_value = 65535
+	port_input.value = 6006
+	port_input.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	port_hbox.add_child(port_input)
+	
+	# Connect button
+	var connect_btn := Button.new()
+	connect_btn.name = "ConnectButton"
+	connect_btn.text = "Start Server"
+	connect_btn.pressed.connect(_on_connect_pressed)
+	vbox.add_child(connect_btn)
+	
+	# Status
+	var status := Label.new()
+	status.name = "StatusLabel"
+	status.text = "Status: Disconnected"
+	status.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	vbox.add_child(status)
+	
+	# Separator
+	vbox.add_child(HSeparator.new())
+	
+	# Info label
+	var info := Label.new()
+	info.text = "Nice2Dev will connect to\\nthis Godot editor instance."
+	info.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	info.autowrap_mode = TextServer.AUTOWRAP_WORD
+	vbox.add_child(info)
+
+
+func _on_connect_pressed() -> void:
+	var port_input := get_node("VBoxContainer/HBoxContainer/PortInput") as SpinBox
+	var connect_btn := get_node("VBoxContainer/ConnectButton") as Button
+	
+	if is_connected:
+		disconnect_requested.emit()
+	else:
+		connect_requested.emit(int(port_input.value))
+
+
+func set_connected(connected: bool) -> void:
+	is_connected = connected
+	
+	var connect_btn := get_node("VBoxContainer/ConnectButton") as Button
+	var status := get_node("VBoxContainer/StatusLabel") as Label
+	
+	if connected:
+		connect_btn.text = "Stop Server"
+		status.text = "Status: Listening..."
+	else:
+		connect_btn.text = "Start Server"
+		status.text = "Status: Disconnected"
+
+
+func set_client_connected(connected: bool, client_id: String = "") -> void:
+	var status := get_node("VBoxContainer/StatusLabel") as Label
+	
+	if connected:
+		status.text = "Status: Connected (%s)" % client_id
+	elif is_connected:
+		status.text = "Status: Listening..."
+`;
+    const serverScript = `@tool
+extends Node
+
+signal client_connected(client_id: String)
+signal client_disconnected(client_id: String)
+signal message_received(type: String, payload: Dictionary)
+
+var tcp_server: TCPServer
+var ws_peers: Dictionary = {}  # peer_id -> WebSocketPeer
+var port: int = 6006
+
+
+func start(p: int) -> void:
+	port = p
+	tcp_server = TCPServer.new()
+	var err := tcp_server.listen(port)
+	if err != OK:
+		push_error("Nice2Dev Live Link: Failed to start server on port %d" % port)
+		return
+	
+	print("Nice2Dev Live Link: Server started on port %d" % port)
+
+
+func stop() -> void:
+	for peer_id in ws_peers.keys():
+		var peer: WebSocketPeer = ws_peers[peer_id]
+		peer.close()
+	ws_peers.clear()
+	
+	if tcp_server:
+		tcp_server.stop()
+		tcp_server = null
+	
+	print("Nice2Dev Live Link: Server stopped")
+
+
+func _process(_delta: float) -> void:
+	if not tcp_server:
+		return
+	
+	# Accept new connections
+	if tcp_server.is_connection_available():
+		var stream := tcp_server.take_connection()
+		var ws := WebSocketPeer.new()
+		ws.accept_stream(stream)
+		var peer_id := stream.get_instance_id()
+		ws_peers[peer_id] = ws
+		print("Nice2Dev Live Link: New connection pending")
+	
+	# Process existing connections
+	for peer_id in ws_peers.keys():
+		var ws: WebSocketPeer = ws_peers[peer_id]
+		ws.poll()
+		
+		var state := ws.get_ready_state()
+		match state:
+			WebSocketPeer.STATE_OPEN:
+				while ws.get_available_packet_count() > 0:
+					var packet := ws.get_packet()
+					_handle_packet(peer_id, packet)
+			
+			WebSocketPeer.STATE_CLOSED:
+				var code := ws.get_close_code()
+				print("Nice2Dev Live Link: Connection closed (%d)" % code)
+				ws_peers.erase(peer_id)
+				client_disconnected.emit(str(peer_id))
+
+
+func _handle_packet(peer_id: int, packet: PackedByteArray) -> void:
+	var text := packet.get_string_from_utf8()
+	var json := JSON.new()
+	var err := json.parse(text)
+	
+	if err != OK:
+		push_warning("Nice2Dev Live Link: Failed to parse message")
+		return
+	
+	var message: Dictionary = json.data
+	var msg_type: String = message.get("type", "")
+	var payload: Dictionary = message.get("payload", {})
+	
+	match msg_type:
+		"handshake":
+			_handle_handshake(peer_id, payload)
+		
+		"scene_tree":
+			_send_scene_tree(peer_id)
+		
+		"node_selected":
+			_handle_node_selection(payload)
+		
+		"node_property_changed":
+			_handle_property_change(payload)
+		
+		"node_added":
+			_handle_node_add(payload)
+		
+		"node_removed":
+			_handle_node_remove(payload)
+		
+		"play_state_changed":
+			_handle_play_state(payload)
+		
+		"ping":
+			_send_pong(peer_id)
+		
+		_:
+			message_received.emit(msg_type, payload)
+
+
+func _handle_handshake(peer_id: int, payload: Dictionary) -> void:
+	var client_id := payload.get("clientId", "unknown")
+	print("Nice2Dev Live Link: Client connected - %s" % client_id)
+	client_connected.emit(client_id)
+	
+	# Send acknowledgment
+	var plugin := _get_plugin()
+	var ack := {
+		"type": "handshake_ack",
+		"timestamp": Time.get_unix_time_from_system() * 1000,
+		"payload": {
+			"version": "1.0.0",
+			"projectName": ProjectSettings.get_setting("application/config/name"),
+			"godotVersion": Engine.get_version_info().string,
+			"editorId": str(get_instance_id()),
+			"capabilities": {
+				"remoteDebug": true,
+				"liveEdit": true,
+				"profiler": true,
+				"visualProfiler": true,
+				"networkProfiler": false
+			}
+		}
+	}
+	_send(peer_id, ack)
+
+
+func _send_scene_tree(peer_id: int) -> void:
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	var tree_data := plugin.get_scene_tree_data()
+	var msg := {
+		"type": "scene_tree",
+		"timestamp": Time.get_unix_time_from_system() * 1000,
+		"payload": tree_data
+	}
+	_send(peer_id, msg)
+
+
+func _handle_node_selection(payload: Dictionary) -> void:
+	var paths: Array = payload.get("paths", [])
+	if paths.is_empty():
+		return
+	
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	var selection := plugin.get_editor_interface().get_selection()
+	selection.clear()
+	
+	var root := plugin.get_editor_interface().get_edited_scene_root()
+	if not root:
+		return
+	
+	for path in paths:
+		var node := root.get_node_or_null(NodePath(path))
+		if node:
+			selection.add_node(node)
+
+
+func _handle_property_change(payload: Dictionary) -> void:
+	var node_path: String = payload.get("nodePath", "")
+	var property: String = payload.get("property", "")
+	var value = payload.get("value")
+	
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	var root := plugin.get_editor_interface().get_edited_scene_root()
+	if not root:
+		return
+	
+	var node := root.get_node_or_null(NodePath(node_path))
+	if node and property:
+		node.set(property, value)
+
+
+func _handle_node_add(payload: Dictionary) -> void:
+	var parent_path: String = payload.get("parentPath", "")
+	var node_type: String = payload.get("nodeType", "Node")
+	var node_name: String = payload.get("name", "NewNode")
+	
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	var root := plugin.get_editor_interface().get_edited_scene_root()
+	if not root:
+		return
+	
+	var parent := root.get_node_or_null(NodePath(parent_path))
+	if not parent:
+		parent = root
+	
+	var new_node := ClassDB.instantiate(node_type)
+	if new_node:
+		new_node.name = node_name
+		parent.add_child(new_node, true)
+		new_node.owner = root
+
+
+func _handle_node_remove(payload: Dictionary) -> void:
+	var node_path: String = payload.get("nodePath", "")
+	
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	var root := plugin.get_editor_interface().get_edited_scene_root()
+	if not root:
+		return
+	
+	var node := root.get_node_or_null(NodePath(node_path))
+	if node and node != root:
+		node.queue_free()
+
+
+func _handle_play_state(payload: Dictionary) -> void:
+	var action: String = payload.get("action", "")
+	var plugin := _get_plugin()
+	if not plugin:
+		return
+	
+	match action:
+		"play":
+			plugin.get_editor_interface().play_main_scene()
+		"stop":
+			plugin.get_editor_interface().stop_playing_scene()
+		"pause":
+			# Toggle pause - requires debugger
+			pass
+
+
+func _send_pong(peer_id: int) -> void:
+	_send(peer_id, {
+		"type": "pong",
+		"timestamp": Time.get_unix_time_from_system() * 1000,
+		"payload": null
+	})
+
+
+func send_selection(paths: Array[String], ids: Array[int]) -> void:
+	_broadcast({
+		"type": "node_selected",
+		"timestamp": Time.get_unix_time_from_system() * 1000,
+		"payload": {
+			"paths": paths,
+			"nodeIds": ids
+		}
+	})
+
+
+func send_filesystem_changed() -> void:
+	_broadcast({
+		"type": "resource_changed",
+		"timestamp": Time.get_unix_time_from_system() * 1000,
+		"payload": {}
+	})
+
+
+func _send(peer_id: int, data: Dictionary) -> void:
+	if ws_peers.has(peer_id):
+		var ws: WebSocketPeer = ws_peers[peer_id]
+		ws.send_text(JSON.stringify(data))
+
+
+func _broadcast(data: Dictionary) -> void:
+	var text := JSON.stringify(data)
+	for peer_id in ws_peers.keys():
+		var ws: WebSocketPeer = ws_peers[peer_id]
+		if ws.get_ready_state() == WebSocketPeer.STATE_OPEN:
+			ws.send_text(text)
+
+
+func _get_plugin() -> EditorPlugin:
+	return get_parent() as EditorPlugin
+`;
+    const pluginCfg = `[plugin]
+
+name="Nice2Dev Live Link"
+description="Real-time synchronization between Godot Editor and Nice2Dev"
+author="Nice2Dev"
+version="1.0.0"
+script="plugin.gd"
+`;
+    return {
+        files: {
+            'addons/nice2dev_live_link/plugin.gd': mainPlugin,
+            'addons/nice2dev_live_link/dock.gd': dockScript,
+            'addons/nice2dev_live_link/server.gd': serverScript,
+            'addons/nice2dev_live_link/plugin.cfg': pluginCfg,
+        },
+        readme: `# Nice2Dev Live Link for Godot
+
+## Installation
+
+1. Copy the \`addons/nice2dev_live_link\` folder to your Godot project's \`addons\` folder.
+2. In Godot, go to Project → Project Settings → Plugins
+3. Enable the "Nice2Dev Live Link" plugin
+
+## Usage
+
+1. The "Nice2Dev Live Link" dock will appear in the editor
+2. Click "Start Server" to begin listening for connections
+3. In Nice2Dev, connect to the Godot editor using the configured port
+
+## Features
+
+- Real-time scene tree synchronization
+- Selection mirroring between editors
+- Remote property editing
+- Play mode control (play/stop)
+- Node creation and deletion
+
+## Protocol
+
+The plugin uses WebSocket for communication with JSON messages.
+Default port: 6006
+`,
+    };
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createGodotLiveLinkClient(config) {
+    return new GodotLiveLinkClient(config);
+}
+
+exports.GodotLiveLinkClient = GodotLiveLinkClient;
+exports.createGodotLiveLinkClient = createGodotLiveLinkClient;
+exports.generateGodotLiveLinkPlugin = generateGodotLiveLinkPlugin;
+//# sourceMappingURL=GodotLiveLink.js.map