CoplayDev · ff6330858 · Apr 24, 2026 · Apr 24, 2026 · coderabbitai · Apr 24, 2026
diff --git a/MCPForUnity/Editor/Clients/Configurators/OpenClawConfigurator.cs b/MCPForUnity/Editor/Clients/Configurators/OpenClawConfigurator.cs
@@ -387,6 +387,11 @@ private ConfiguredTransport ResolveTransport(JObject server)
                 return ConfiguredTransport.HttpRemote;
             }
 
+            if (UrlsEqual(configuredUrl, HttpEndpointUtility.GetLanMcpRpcUrl()))
+            {
+                return ConfiguredTransport.HttpLan;
+            }
+
             if (UrlsEqual(configuredUrl, HttpEndpointUtility.GetLocalMcpRpcUrl()))
             {
                 return ConfiguredTransport.Http;

diff --git a/MCPForUnity/Editor/Clients/McpClientConfiguratorBase.cs b/MCPForUnity/Editor/Clients/McpClientConfiguratorBase.cs
@@ -203,10 +203,15 @@ public override McpStatus CheckStatus(bool attemptAutoRewrite = true)
                     // Distinguish HTTP Local from HTTP Remote by matching against both URLs
                     string localRpcUrl = HttpEndpointUtility.GetLocalMcpRpcUrl();
                     string remoteRpcUrl = HttpEndpointUtility.GetRemoteMcpRpcUrl();
+                    string lanRpcUrl = HttpEndpointUtility.GetLanMcpRpcUrl();
                     if (!string.IsNullOrEmpty(remoteRpcUrl) && UrlsEqual(configuredUrl, remoteRpcUrl))
                     {
                         client.configuredTransport = Models.ConfiguredTransport.HttpRemote;
                     }
+                    else if (!string.IsNullOrEmpty(lanRpcUrl) && UrlsEqual(configuredUrl, lanRpcUrl))
+                    {
+                        client.configuredTransport = Models.ConfiguredTransport.HttpLan;
+                    }
                     else
                     {
                         client.configuredTransport = Models.ConfiguredTransport.Http;
@@ -377,10 +382,15 @@ public override McpStatus CheckStatus(bool attemptAutoRewrite = true)
                     {
                         // Distinguish HTTP Local from HTTP Remote
                         string remoteRpcUrl = HttpEndpointUtility.GetRemoteMcpRpcUrl();
+                        string lanRpcUrl = HttpEndpointUtility.GetLanMcpRpcUrl();
                         if (!string.IsNullOrEmpty(remoteRpcUrl) && UrlsEqual(url, remoteRpcUrl))
                         {
                             client.configuredTransport = Models.ConfiguredTransport.HttpRemote;
                         }
+                        else if (!string.IsNullOrEmpty(lanRpcUrl) && UrlsEqual(url, lanRpcUrl))
+                        {
+                            client.configuredTransport = Models.ConfiguredTransport.HttpLan;
+                        }
                         else
                         {
                             client.configuredTransport = Models.ConfiguredTransport.Http;
@@ -581,23 +591,24 @@ public override McpStatus CheckStatus(bool attemptAutoRewrite = true)
             string claudePath = MCPServiceLocator.Paths.GetClaudeCliPath();
             RuntimePlatform platform = Application.platform;
             bool isRemoteScope = HttpEndpointUtility.IsRemoteScope();
+            bool isLanScope = HttpEndpointUtility.IsLanScope();
             // Get expected package source for the installed package version (matches what Register() would use)
             string expectedPackageSource = GetExpectedPackageSourceForValidation();
-            return CheckStatusWithProjectDir(projectDir, useHttpTransport, claudePath, platform, isRemoteScope, expectedPackageSource, attemptAutoRewrite, HasClientProjectDirOverride);
+            return CheckStatusWithProjectDir(projectDir, useHttpTransport, claudePath, platform, isRemoteScope, isLanScope, expectedPackageSource, attemptAutoRewrite, HasClientProjectDirOverride);
         }
 
         /// <summary>
         /// Internal thread-safe version of CheckStatus.
         /// Can be called from background threads because all main-thread-only values are passed as parameters.
-        /// projectDir, useHttpTransport, claudePath, platform, isRemoteScope, and expectedPackageSource are REQUIRED
+        /// projectDir, useHttpTransport, claudePath, platform, isRemoteScope, isLanScope, and expectedPackageSource are REQUIRED
         /// (non-nullable where applicable) to enforce thread safety at compile time.
         /// NOTE: attemptAutoRewrite is NOT fully thread-safe because Configure() requires the main thread.
         /// When called from a background thread, pass attemptAutoRewrite=false and handle re-registration
         /// on the main thread based on the returned status.
         /// </summary>
         internal McpStatus CheckStatusWithProjectDir(
             string projectDir, bool useHttpTransport, string claudePath, RuntimePlatform platform,
-            bool isRemoteScope, string expectedPackageSource,
+            bool isRemoteScope, bool isLanScope, string expectedPackageSource,
             bool attemptAutoRewrite = false, bool hasProjectDirOverride = false)
         {
             try
@@ -647,7 +658,7 @@ internal McpStatus CheckStatusWithProjectDir(
                 {
                     client.configuredTransport = isRemoteScope
                         ? Models.ConfiguredTransport.HttpRemote
-                        : Models.ConfiguredTransport.Http;
+                        : (isLanScope ? Models.ConfiguredTransport.HttpLan : Models.ConfiguredTransport.Http);
                 }
                 else if (registeredWithStdio)
                 {

diff --git a/MCPForUnity/Editor/Constants/EditorPrefKeys.cs b/MCPForUnity/Editor/Constants/EditorPrefKeys.cs
@@ -7,7 +7,7 @@ namespace MCPForUnity.Editor.Constants
     internal static class EditorPrefKeys
     {
         internal const string UseHttpTransport = "MCPForUnity.UseHttpTransport";
-        internal const string HttpTransportScope = "MCPForUnity.HttpTransportScope"; // "local" | "remote"
+        internal const string HttpTransportScope = "MCPForUnity.HttpTransportScope"; // "local" | "remote" | "lan"
         internal const string LastLocalHttpServerPid = "MCPForUnity.LocalHttpServer.LastPid";
         internal const string LastLocalHttpServerPort = "MCPForUnity.LocalHttpServer.LastPort";
         internal const string LastLocalHttpServerStartedUtc = "MCPForUnity.LocalHttpServer.LastStartedUtc";
@@ -26,6 +26,8 @@ internal static class EditorPrefKeys
 
         internal const string HttpBaseUrl = "MCPForUnity.HttpUrl";
         internal const string HttpRemoteBaseUrl = "MCPForUnity.HttpRemoteUrl";
+        internal const string HttpLanPublicBaseUrl = "MCPForUnity.HttpLanPublicUrl";
+        internal const string HttpLanBindBaseUrl = "MCPForUnity.HttpLanBindUrl";
         internal const string SessionId = "MCPForUnity.SessionId";
         internal const string WebSocketUrlOverride = "MCPForUnity.WebSocketUrl";
         internal const string GitUrlOverride = "MCPForUnity.GitUrlOverride";

diff --git a/MCPForUnity/Editor/Helpers/HttpEndpointUtility.cs b/MCPForUnity/Editor/Helpers/HttpEndpointUtility.cs
@@ -19,16 +19,22 @@ public static class HttpEndpointUtility
     {
         private const string LocalPrefKey = EditorPrefKeys.HttpBaseUrl;
         private const string RemotePrefKey = EditorPrefKeys.HttpRemoteBaseUrl;
+        private const string LanPublicPrefKey = EditorPrefKeys.HttpLanPublicBaseUrl;
+        private const string LanBindPrefKey = EditorPrefKeys.HttpLanBindBaseUrl;
         private const string DefaultLocalBaseUrl = "http://127.0.0.1:8080";
         private const string DefaultRemoteBaseUrl = "";
+        private const string DefaultLanPublicBaseUrl = "http://192.168.1.10:8090";
+        private const string DefaultLanBindBaseUrl = "http://0.0.0.0:8090";
 
         /// <summary>
         /// Returns the normalized base URL for the currently active HTTP scope.
         /// If the scope is "remote", returns the remote URL; otherwise returns the local URL.
         /// </summary>
         public static string GetBaseUrl()
         {
-            return IsRemoteScope() ? GetRemoteBaseUrl() : GetLocalBaseUrl();
+            if (IsRemoteScope()) return GetRemoteBaseUrl();
+            if (IsLanScope()) return GetLanPublicBaseUrl();
+            return GetLocalBaseUrl();
         }
 
         /// <summary>
@@ -40,6 +46,10 @@ public static void SaveBaseUrl(string userValue)
             {
                 SaveRemoteBaseUrl(userValue);
             }
+            else if (IsLanScope())
+            {
+                SaveLanPublicBaseUrl(userValue);
+            }
             else
             {
                 SaveLocalBaseUrl(userValue);
@@ -78,6 +88,47 @@ public static string GetRemoteBaseUrl()
             return NormalizeBaseUrl(stored, DefaultRemoteBaseUrl, remoteScope: true);
         }
 
+        /// <summary>
+        /// Returns the normalized LAN public URL that remote clients should use.
+        /// </summary>
+        public static string GetLanPublicBaseUrl()
+        {
+            string stored = EditorPrefs.GetString(LanPublicPrefKey, DefaultLanPublicBaseUrl);
+            return NormalizeBaseUrl(stored, DefaultLanPublicBaseUrl, remoteScope: false);
+        }
+
+        /// <summary>
+        /// Saves the LAN public URL and keeps the bind URL on 0.0.0.0 with the same port.
+        /// </summary>
+        public static void SaveLanPublicBaseUrl(string userValue)
+        {
+            string normalized = NormalizeBaseUrl(userValue, DefaultLanPublicBaseUrl, remoteScope: false);
+            EditorPrefs.SetString(LanPublicPrefKey, normalized);
+
+            if (Uri.TryCreate(normalized, UriKind.Absolute, out var uri) && uri.Port > 0)
+            {
+                EditorPrefs.SetString(LanBindPrefKey, $"http://0.0.0.0:{uri.Port}");
+            }
+        }
-        public static void SaveLanPublicBaseUrl(string userValue)
-        {
-            string normalized = NormalizeBaseUrl(userValue, DefaultLanPublicBaseUrl, remoteScope: false);
-            EditorPrefs.SetString(LanPublicPrefKey, normalized);
-
-            if (Uri.TryCreate(normalized, UriKind.Absolute, out var uri) && uri.Port > 0)
-            {
-                EditorPrefs.SetString(LanBindPrefKey, $"http://0.0.0.0:{uri.Port}");
-            }
-        }
+        public static void SaveLanPublicBaseUrl(string userValue)
+        {
+            string normalized = NormalizeBaseUrl(userValue, DefaultLanPublicBaseUrl, remoteScope: false);
+            EditorPrefs.SetString(LanPublicPrefKey, normalized);
+
+            // Only sync the bind URL when the user supplied an explicit port.
+            // Uri.Port falls back to the scheme default (80 for http), so `> 0` alone would
+            // silently rewrite the bind URL to port 80 when the user omitted the port.
+            if (Uri.TryCreate(normalized, UriKind.Absolute, out var uri) && !uri.IsDefaultPort && uri.Port > 0)
+            {
+                EditorPrefs.SetString(LanBindPrefKey, $"http://0.0.0.0:{uri.Port}");
+            }
+        }
-        public static void SaveLanPublicBaseUrl(string userValue)
-        {
-            string normalized = NormalizeBaseUrl(userValue, DefaultLanPublicBaseUrl, remoteScope: false);
-            EditorPrefs.SetString(LanPublicPrefKey, normalized);
-
-            if (Uri.TryCreate(normalized, UriKind.Absolute, out var uri) && uri.Port > 0)
-            {
-                EditorPrefs.SetString(LanBindPrefKey, $"http://0.0.0.0:{uri.Port}");
-            }
-        }
+        public static void SaveLanPublicBaseUrl(string userValue)
+        {
+            string normalized = NormalizeBaseUrl(userValue, DefaultLanPublicBaseUrl, remoteScope: false);
+            EditorPrefs.SetString(LanPublicPrefKey, normalized);
+
+            // Only sync the bind URL when the user supplied an explicit port.
+            // Uri.Port falls back to the scheme default (80 for http), so `> 0` alone would
+            // silently rewrite the bind URL to port 80 when the user omitted the port.
+            if (Uri.TryCreate(normalized, UriKind.Absolute, out var uri) && !uri.IsDefaultPort && uri.Port > 0)
+            {
+                EditorPrefs.SetString(LanBindPrefKey, $"http://0.0.0.0:{uri.Port}");
+            }
+        }
+
+        /// <summary>
+        /// Returns the LAN bind URL used to launch the local server.
+        /// </summary>
+        public static string GetLanBindBaseUrl()
+        {
+            string stored = EditorPrefs.GetString(LanBindPrefKey, DefaultLanBindBaseUrl);
+            return NormalizeBaseUrl(stored, DefaultLanBindBaseUrl, remoteScope: false);
+        }
+
+        /// <summary>
+        /// Returns the URL used to launch/probe/stop the local server process.
+        /// LAN mode binds all interfaces while exposing a separate public client URL.
+        /// </summary>
+        public static string GetLocalServerLaunchBaseUrl()
+        {
+            return IsLanScope() ? GetLanBindBaseUrl() : GetLocalBaseUrl();
+        }
+
         /// <summary>
         /// Saves a user-provided URL to the remote HTTP pref.
         /// </summary>
@@ -108,6 +159,14 @@ public static string GetLocalMcpRpcUrl()
             return AppendPathSegment(GetLocalBaseUrl(), "mcp");
         }
 
+        /// <summary>
+        /// Builds the LAN public JSON-RPC endpoint (public base + /mcp).
+        /// </summary>
+        public static string GetLanMcpRpcUrl()
+        {
+            return AppendPathSegment(GetLanPublicBaseUrl(), "mcp");
+        }
+
         /// <summary>
         /// Builds the remote JSON-RPC endpoint (remote base + /mcp).
         /// Returns empty string if no remote URL is configured.
@@ -135,6 +194,15 @@ public static bool IsRemoteScope()
             return string.Equals(scope, "remote", StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <summary>
+        /// Returns true if the active HTTP transport scope is "lan".
+        /// </summary>
+        public static bool IsLanScope()
+        {
+            string scope = EditorConfigurationCache.Instance.HttpTransportScope;
+            return string.Equals(scope, "lan", StringComparison.OrdinalIgnoreCase);
+        }
+
         /// <summary>
         /// Returns the <see cref="ConfiguredTransport"/> that matches the current server-side
         /// transport selection (Stdio, Http, or HttpRemote).
@@ -144,6 +212,7 @@ public static ConfiguredTransport GetCurrentServerTransport()
         {
             bool useHttp = EditorConfigurationCache.Instance.UseHttpTransport;
             if (!useHttp) return ConfiguredTransport.Stdio;
+            if (IsLanScope()) return ConfiguredTransport.HttpLan;
             return IsRemoteScope() ? ConfiguredTransport.HttpRemote : ConfiguredTransport.Http;
         }
 
@@ -249,6 +318,46 @@ public static bool IsHttpLocalUrlAllowedForLaunch(string url, out string error)
             return false;
         }
 
+        /// <summary>
+        /// Returns true when the URL is acceptable for LAN HTTP launch.
+        /// LAN mode intentionally binds all interfaces for trusted private networks.
+        /// </summary>
+        public static bool IsHttpLanUrlAllowedForLaunch(string url, out string error)
+        {
+            error = null;
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                error = "LAN HTTP requires a bind URL such as http://0.0.0.0:8090.";
+                return false;
+            }
+
+            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+            {
+                error = $"Invalid LAN HTTP bind URL: {url}";
+                return false;
+            }
+
+            if (!uri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
+            {
+                error = "LAN HTTP bind URL must use http://.";
+                return false;
+            }
+
+            if (uri.Port <= 0)
+            {
+                error = "LAN HTTP bind URL requires an explicit port.";
+                return false;
+            }
+
+            if (IsBindAllInterfacesHost(uri.Host))
+            {
+                return true;
+            }
+
+            error = "LAN HTTP server bind host must be 0.0.0.0 or ::.";
+            return false;
+        }
-        public static bool IsHttpLanUrlAllowedForLaunch(string url, out string error)
-        {
-            error = null;
-            if (string.IsNullOrWhiteSpace(url))
-            {
-                error = "LAN HTTP requires a bind URL such as http://0.0.0.0:8090.";
-                return false;
-            }
-
-            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
-            {
-                error = $"Invalid LAN HTTP bind URL: {url}";
-                return false;
-            }
-
-            if (!uri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
-            {
-                error = "LAN HTTP bind URL must use http://.";
-                return false;
-            }
-
-            if (uri.Port <= 0)
-            {
-                error = "LAN HTTP bind URL requires an explicit port.";
-                return false;
-            }
-
-            if (IsBindAllInterfacesHost(uri.Host))
-            {
-                return true;
-            }
-
-            error = "LAN HTTP server bind host must be 0.0.0.0 or ::.";
-            return false;
-        }
+        public static bool IsHttpLanUrlAllowedForLaunch(string url, out string error)
+        {
+            error = null;
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                error = "LAN HTTP requires a bind URL such as http://0.0.0.0:8090.";
+                return false;
+            }
+
+            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+            {
+                error = $"Invalid LAN HTTP bind URL: {url}";
+                return false;
+            }
+
+            if (!uri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
+            {
+                error = "LAN HTTP bind URL must use http://.";
+                return false;
+            }
+
+            // Uri.Port returns the scheme default (80) when unspecified, so use IsDefaultPort
+            // to require the user to supply an explicit port for LAN bind URLs.
+            if (uri.IsDefaultPort)
+            {
+                error = "LAN HTTP bind URL requires an explicit port.";
+                return false;
+            }
+
+            if (IsBindAllInterfacesHost(uri.Host))
+            {
+                return true;
+            }
+
+            error = "LAN HTTP server bind host must be 0.0.0.0 or ::.";
+            return false;
+        }
-        public static bool IsHttpLanUrlAllowedForLaunch(string url, out string error)
-        {
-            error = null;
-            if (string.IsNullOrWhiteSpace(url))
-            {
-                error = "LAN HTTP requires a bind URL such as http://0.0.0.0:8090.";
-                return false;
-            }
-
-            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
-            {
-                error = $"Invalid LAN HTTP bind URL: {url}";
-                return false;
-            }
-
-            if (!uri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
-            {
-                error = "LAN HTTP bind URL must use http://.";
-                return false;
-            }
-
-            if (uri.Port <= 0)
-            {
-                error = "LAN HTTP bind URL requires an explicit port.";
-                return false;
-            }
-
-            if (IsBindAllInterfacesHost(uri.Host))
-            {
-                return true;
-            }
-
-            error = "LAN HTTP server bind host must be 0.0.0.0 or ::.";
-            return false;
-        }
+        public static bool IsHttpLanUrlAllowedForLaunch(string url, out string error)
+        {
+            error = null;
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                error = "LAN HTTP requires a bind URL such as http://0.0.0.0:8090.";
+                return false;
+            }
+
+            if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+            {
+                error = $"Invalid LAN HTTP bind URL: {url}";
+                return false;
+            }
+
+            if (!uri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
+            {
+                error = "LAN HTTP bind URL must use http://.";
+                return false;
+            }
+
+            // Uri.Port returns the scheme default (80) when unspecified, so use IsDefaultPort
+            // to require the user to supply an explicit port for LAN bind URLs.
+            if (uri.IsDefaultPort)
+            {
+                error = "LAN HTTP bind URL requires an explicit port.";
+                return false;
+            }
+
+            if (IsBindAllInterfacesHost(uri.Host))
+            {
+                return true;
+            }
+
+            error = "LAN HTTP server bind host must be 0.0.0.0 or ::.";
+            return false;
+        }
+
         /// <summary>
         /// Returns true when remote URL is allowed by current security policy.
         /// HTTPS is required by default; HTTP needs explicit opt-in.

diff --git a/MCPForUnity/Editor/Models/McpStatus.cs b/MCPForUnity/Editor/Models/McpStatus.cs
@@ -25,7 +25,8 @@ public enum ConfiguredTransport
         Unknown,    // Could not determine transport type
         Stdio,      // Client configured for stdio transport
         Http,       // Client configured for HTTP local transport
-        HttpRemote  // Client configured for HTTP remote-hosted transport
+        HttpRemote, // Client configured for HTTP remote-hosted transport
+        HttpLan     // Client configured for LAN HTTP transport
     }
 }
 
diff --git a/MCPForUnity/Editor/Services/HttpAutoStartHandler.cs b/MCPForUnity/Editor/Services/HttpAutoStartHandler.cs
@@ -73,8 +73,12 @@ private static async Task AutoStartAsync()
                 {
                     // For HTTP Local: launch the server process first, then connect the bridge.
                     // This mirrors what the UI "Start Server" button does.
-                    if (!HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(
-                            HttpEndpointUtility.GetLocalBaseUrl(), out string policyError))
+                    string launchBaseUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
+                    string policyError;
+                    bool launchAllowed = HttpEndpointUtility.IsLanScope()
+                        ? HttpEndpointUtility.IsHttpLanUrlAllowedForLaunch(launchBaseUrl, out policyError)
+                        : HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(launchBaseUrl, out policyError);
+                    if (!launchAllowed)
                     {
                         McpLog.Debug($"[HTTP Auto-Start] Local URL blocked by security policy: {policyError}");
                         return;

diff --git a/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs b/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs
@@ -51,6 +51,7 @@ private static void OnEditorQuitting()
                 bool httpLocalSelected =
                     useHttp &&
                     (string.Equals(scope, "local", StringComparison.OrdinalIgnoreCase)
+                     || string.Equals(scope, "lan", StringComparison.OrdinalIgnoreCase)
                      || (string.IsNullOrEmpty(scope) && MCPServiceLocator.Server.IsLocalUrl()));
 
                 if (httpLocalSelected)

diff --git a/MCPForUnity/Editor/Services/Server/ServerCommandBuilder.cs b/MCPForUnity/Editor/Services/Server/ServerCommandBuilder.cs
@@ -30,8 +30,12 @@ public bool TryBuildCommand(out string fileName, out string arguments, out strin
                 return false;
             }
 
-            string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
-            if (!HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(httpUrl, out string localUrlError))
+            string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
+            string localUrlError;
+            bool launchUrlAllowed = HttpEndpointUtility.IsLanScope()
+                ? HttpEndpointUtility.IsHttpLanUrlAllowedForLaunch(httpUrl, out localUrlError)
+                : HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(httpUrl, out localUrlError);
+            if (!launchUrlAllowed)
             {
                 error = string.IsNullOrEmpty(localUrlError)
                     ? $"The configured URL ({httpUrl}) is not allowed for HTTP Local launch."

diff --git a/MCPForUnity/Editor/Services/ServerManagementService.cs b/MCPForUnity/Editor/Services/ServerManagementService.cs
@@ -256,7 +256,7 @@ public bool StartLocalHttpServer(bool quiet = false)
             // If the port is still occupied, don't start and explain why (avoid confusing "refusing to stop" warnings).
             try
             {
-                string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
+                string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
                 if (Uri.TryCreate(httpUrl, UriKind.Absolute, out var uri) && uri.Port > 0)
                 {
                     var remaining = GetListeningProcessIdsForPort(uri.Port);
@@ -280,7 +280,7 @@ public bool StartLocalHttpServer(bool quiet = false)
             // Note: Dev mode cache-busting is handled by `uvx --no-cache --refresh` in the generated command.
 
             // Create a per-launch token + pidfile path so Stop can be deterministic without relying on port/PID heuristics.
-            string baseUrlForPid = HttpEndpointUtility.GetLocalBaseUrl();
+            string baseUrlForPid = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
             Uri.TryCreate(baseUrlForPid, UriKind.Absolute, out var uriForPid);
             int portForPid = uriForPid?.Port ?? 0;
             string instanceToken = Guid.NewGuid().ToString("N");
@@ -359,7 +359,7 @@ public bool StopManagedLocalHttpServer()
             int port = 0;
             if (!TryGetPortFromPidFilePath(pidFilePath, out port) || port <= 0)
             {
-                string baseUrl = HttpEndpointUtility.GetLocalBaseUrl();
+                string baseUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
                 if (IsLocalUrl(baseUrl)
                     && Uri.TryCreate(baseUrl, UriKind.Absolute, out var uri)
                     && uri.Port > 0)
@@ -380,7 +380,7 @@ public bool IsLocalHttpServerRunning()
         {
             try
             {
-                string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
+                string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
                 if (!IsLocalUrl(httpUrl))
                 {
                     return false;
@@ -442,7 +442,7 @@ public bool IsLocalHttpServerReachable()
         {
             try
             {
-                string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
+                string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
                 if (!IsLocalUrl(httpUrl))
                 {
                     return false;
@@ -543,7 +543,7 @@ private static void AddHostCandidate(List<string> hosts, string candidate)
 
         private bool StopLocalHttpServerInternal(bool quiet, int? portOverride = null, bool allowNonLocalUrl = false)
         {
-            string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
+            string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
             if (!allowNonLocalUrl && !IsLocalUrl(httpUrl))
             {
                 if (!quiet)
@@ -898,7 +898,7 @@ private bool TryGetLocalHttpServerCommandParts(out string fileName, out string a
         /// </summary>
         public bool IsLocalUrl()
         {
-            string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
+            string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
             return IsLocalUrl(httpUrl);
         }
 
@@ -933,8 +933,10 @@ public bool CanStartLocalServer()
                 return false;
             }
 
-            string httpUrl = HttpEndpointUtility.GetLocalBaseUrl();
-            return HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(httpUrl, out _);
+            string httpUrl = HttpEndpointUtility.GetLocalServerLaunchBaseUrl();
+            return HttpEndpointUtility.IsLanScope()
+                ? HttpEndpointUtility.IsHttpLanUrlAllowedForLaunch(httpUrl, out _)
+                : HttpEndpointUtility.IsHttpLocalUrlAllowedForLaunch(httpUrl, out _);
         }
 
         private System.Diagnostics.ProcessStartInfo CreateTerminalProcessStartInfo(string command)