refactor editor detection to use .internal/editor.port over port/process scanning, fix #46

Author: atomicptr

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "defold-nvim-bridge"
-version = "0.1.4"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]

crates/bridge/Cargo.toml

@@ -81,13 +81,16 @@ enum Commands {
         game_root_dir: String,
     },
     /// Finds the open editor port
-    FindEditorPort,
+    FindEditorPort {
+        #[clap(value_name = "GAME_ROOT_DIR", index = 1)]
+        game_root_dir: String,
+    },
     /// Sends a command to the editor
     SendCommand {
-        #[clap(long = "port")]
-        port: Option<u16>,
+        #[clap(value_name = "GAME_ROOT_DIR", index = 1)]
+        game_root_dir: String,
 
-        #[clap(value_name = "COMMAND", index = 1)]
+        #[clap(value_name = "COMMAND", index = 2)]
         command: String,
     },
     /// Compile `.script_api` file and return the resulting `.lua` in stdout
@@ -186,15 +189,20 @@ fn main() -> Result<()> {
                 tracing::info!("{}", dir.display());
             }
         }
-        Commands::FindEditorPort => {
-            if let Some(port) = editor::find_port() {
+        Commands::FindEditorPort { game_root_dir } => {
+            if let Some(port) = editor::find_port(&absolute(game_root_dir)?) {
                 println!("Editor is running at port {port}");
             } else {
                 println!("Could not find editor port, is the editor open?");
             }
         }
-        Commands::SendCommand { port, command } => {
-            editor::send_command(port, &command)?;
+        Commands::SendCommand {
+            game_root_dir,
+            command,
+        } => {
+            if let Some(port) = editor::find_port(&absolute(game_root_dir)?) {
+                editor::send_command(port, &command)?;
+            }
         }
         Commands::CompileScriptApi { input } => {
             if !input.exists() {

crates/bridge/src/main.rs

@@ -1,6 +1,6 @@
 [package]
 name = "defold-nvim-core"
-version = "0.1.4"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]
@@ -10,23 +10,20 @@ version-compare = "0.2.1"
 flate2 = "1.1.5"
 zip = "7.0.0"
 dirs = "6.0.0"
-reqwest = { version = "0.12.28", default-features = false, features = [
+reqwest = { version = "0.13.1", default-features = false, features = [
     "blocking",
     "json",
-    "rustls-tls",
 ] }
 rust-ini = "0.21.3"
 serde = { version = "1.0.228", features = ["derive"] }
-serde_json = "1.0.147"
+serde_json = "1.0.148"
 sha3 = "0.10.8"
 strum = { version = "0.27.2", features = ["derive"] }
 tracing = "0.1.44"
 which = "8.0.0"
 url = "2.5.7"
 walkdir = "2.5.0"
 edn-rs = "0.18.0"
-netstat2 = "0.11.2"
-sysinfo = "0.37.2"
 serde_yaml = "0.9.34"
 textwrap = "0.16.2"
 fs_extra = "1.3.0"

crates/core/Cargo.toml

@@ -1,9 +1,6 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, fs, path::Path};
 
-use crate::cache;
-use anyhow::{Context, Result, bail};
-use netstat2::{AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, iterate_sockets_info};
-use sysinfo::System;
+use anyhow::{Result, bail};
 
 fn command_url(port: u16, command: Option<String>) -> String {
     format!(
@@ -12,97 +9,36 @@ fn command_url(port: u16, command: Option<String>) -> String {
     )
 }
 
-pub fn find_port() -> Option<u16> {
-    const CACHE: &str = "editor-port";
+#[must_use]
+pub fn find_port(game_root: &Path) -> Option<u16> {
+    let editor_port = game_root.join(".internal").join("editor.port");
 
-    if let Some(port) = cache::get(CACHE)
-        && let Some(port) = port.parse::<u16>().ok()
-        && is_editor_port(port)
-    {
-        return Some(port);
+    // editor port file doesnt exist? Editor isn't open
+    if !editor_port.exists() {
+        return None;
     }
 
-    tracing::debug!("Looking for editor port...");
+    let content = fs::read_to_string(editor_port).ok()?;
 
-    let sys = System::new_all();
+    let port: u16 = content.parse().ok()?;
 
-    for (pid, proc) in sys.processes() {
-        if !proc
-            .name()
-            .to_ascii_lowercase()
-            .to_str()
-            .unwrap_or_default()
-            .contains("java")
-        {
-            continue;
-        }
-
-        let ports = ports_for_pid(pid.as_u32());
-
-        if ports.is_err() {
-            continue;
-        }
-
-        let ports = ports.unwrap();
-        if ports.is_empty() {
-            continue;
-        }
-
-        tracing::debug!("Pid {} has ports: {:?}", pid.as_u32(), ports);
-
-        for port in ports {
-            if is_editor_port(port) {
-                tracing::debug!("Found editor at {port}");
-
-                if let Err(err) = cache::set(CACHE, &port.to_string()) {
-                    tracing::error!("Could not cache editor key because: {err:?}");
-                }
-
-                return Some(port);
-            }
-        }
-    }
-
-    None
-}
-
-fn ports_for_pid(pid: u32) -> Result<Vec<u16>> {
-    let mut ports = Vec::new();
-
-    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
-    let proto_flags = ProtocolFlags::TCP | ProtocolFlags::UDP;
-
-    for socket in iterate_sockets_info(af_flags, proto_flags)? {
-        let socket = socket?;
-
-        if socket.associated_pids.contains(&pid) {
-            match &socket.protocol_socket_info {
-                ProtocolSocketInfo::Tcp(tcp) => {
-                    ports.push(tcp.local_port);
-                }
-                ProtocolSocketInfo::Udp(udp) => {
-                    ports.push(udp.local_port);
-                }
-            }
-        }
+    if is_editor_port(port) {
+        Some(port)
+    } else {
+        None
     }
-
-    Ok(ports)
 }
 
+#[must_use]
 pub fn is_editor_port(port: u16) -> bool {
     reqwest::blocking::Client::new()
         .head(command_url(port, None))
         .send()
         .is_ok_and(|r| r.status().is_success())
 }
 
-pub fn list_commands(port: Option<u16>) -> Result<HashMap<String, String>> {
-    let url = command_url(
-        port.or_else(find_port)
-            .context("could not determine editor port")?,
-        None,
-    );
+pub fn list_commands(port: u16) -> Result<HashMap<String, String>> {
+    let url = command_url(port, None);
 
     let res = reqwest::blocking::get(url)?;
 
@@ -115,12 +51,8 @@ pub fn list_commands(port: Option<u16>) -> Result<HashMap<String, String>> {
     serde_json::from_str(&content).map_err(anyhow::Error::from)
 }
 
-pub fn send_command(port: Option<u16>, cmd: &str) -> Result<()> {
-    let url = command_url(
-        port.or_else(find_port)
-            .context("could not determine editor port")?,
-        Some(cmd.to_string()),
-    );
+pub fn send_command(port: u16, cmd: &str) -> Result<()> {
+    let url = command_url(port, Some(cmd.to_string()));
 
     let res = reqwest::blocking::Client::new().post(url).send()?;
 

crates/core/src/editor.rs

@@ -1,6 +1,6 @@
 [package]
 name = "defold-nvim-sidecar"
-version = "0.1.4"
+version = "0.2.0"
 edition = "2024"
 
 [lib]

crates/sidecar/Cargo.toml

@@ -83,7 +83,6 @@ fn register_exports(lua: &Lua) -> LuaResult<LuaTable> {
     exports.set("version", lua.create_string(utils::version())?)?;
     exports.set("set_log_level", lua.create_function(set_log_level)?)?;
     exports.set("read_game_project", lua.create_function(read_game_project)?)?;
-    exports.set("find_editor_port", lua.create_function(find_editor_port)?)?;
     exports.set("is_editor_port", lua.create_function(is_editor_port)?)?;
     exports.set("list_commands", lua.create_function(list_commands)?)?;
     exports.set("send_command", lua.create_function(send_command)?)?;
@@ -134,27 +133,21 @@ fn read_game_project(lua: &Lua, path: String) -> LuaResult<Value> {
     Ok(val)
 }
 
-#[instrument(level = "debug", err(Debug), skip_all)]
-fn find_editor_port(_lua: &Lua, _: ()) -> LuaResult<u16> {
-    let port = editor::find_port().context("could not find port")?;
-    Ok(port)
-}
-
 #[allow(clippy::unnecessary_wraps)]
 #[instrument(level = "debug", err(Debug), skip_all)]
 fn is_editor_port(_lua: &Lua, port: u16) -> LuaResult<bool> {
     Ok(editor::is_editor_port(port))
 }
 
 #[instrument(level = "debug", err(Debug), skip_all)]
-fn list_commands(lua: &Lua, port: Option<u16>) -> LuaResult<LuaTable> {
+fn list_commands(lua: &Lua, port: u16) -> LuaResult<LuaTable> {
     let commands = editor::list_commands(port)?;
 
     lua.create_table_from(commands)
 }
 
 #[instrument(level = "debug", err(Debug), skip_all)]
-fn send_command(_lua: &Lua, (port, cmd): (Option<u16>, String)) -> LuaResult<()> {
+fn send_command(_lua: &Lua, (port, cmd): (u16, String)) -> LuaResult<()> {
     editor::send_command(port, &cmd)?;
 
     Ok(())

crates/sidecar/src/lib.rs

@@ -1,10 +1,18 @@
 local M = {}
 
 ---List all available Defold commands
----@param port integer|nil
 ---@return table|nil
-function M.list_commands(port)
+function M.list_commands()
     local log = require "defold.service.logger"
+    local project = require "defold.project"
+
+    local port = project.editor_port()
+
+    if not port then
+        log.error "Could not find Defold editor, is it running?"
+        return
+    end
+
     local sidecar = require "defold.sidecar"
 
     local ok, res = pcall(sidecar.list_commands, port)
@@ -19,11 +27,23 @@ function M.list_commands(port)
 end
 
 ---Sends a command to the Defold editor
----@param port integer|nil
 ---@param command string
 ---@param dont_report_error boolean|nil
-function M.send_command(port, command, dont_report_error)
+function M.send_command(command, dont_report_error)
     local log = require "defold.service.logger"
+    local project = require "defold.project"
+
+    local port = project.editor_port()
+
+    if not port then
+        if dont_report_error then
+            return
+        end
+
+        log.error "Could not find Defold editor, is it running?"
+        return
+    end
+
     local sidecar = require "defold.sidecar"
 
     local _, err = pcall(sidecar.send_command, port, command)