Add an MCP server for driving and observing a client through rsprox

build.gradle.kts

@@ -71,6 +71,7 @@ subprojects {
 dependencies {
     runtimeOnly(projects.gui.proxyTool)
     runtimeOnly(projects.proxy)
+    runtimeOnly(projects.mcp)
 }
 
 buildscript {

gui/proxy-tool/src/main/kotlin/net/rsprox/gui/App.kt

@@ -11,6 +11,7 @@ import net.rsprox.gui.dialogs.AboutDialog
 import net.rsprox.gui.sessions.SessionsPanel
 import net.rsprox.gui.sidebar.SideBar
 import net.rsprox.proxy.ProxyService
+import net.rsprox.proxy.StartedExtensions
 import net.rsprox.proxy.config.BINARY_PATH
 import net.rsprox.proxy.config.ERROR_LOGS_PATH
 import java.awt.CardLayout
@@ -24,6 +25,7 @@ import java.awt.event.WindowEvent
 import java.net.URI
 import java.util.prefs.Preferences
 import javax.swing.BorderFactory
+import javax.swing.JCheckBoxMenuItem
 import javax.swing.JFrame
 import javax.swing.JMenu
 import javax.swing.JMenuItem
@@ -33,7 +35,9 @@ import javax.swing.KeyStroke
 import javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE
 import kotlin.system.exitProcess
 
-public class App {
+public class App(
+    private val extensions: StartedExtensions,
+) {
     private val frame: JFrame = JFrame()
     private val sessionsPanel: SessionsPanel = SessionsPanel(this)
     private val launchBar: LaunchBar = LaunchBar(sessionsPanel)
@@ -169,6 +173,20 @@ public class App {
 
                 addSeparator()
 
+                val serveMcpEndpoint =
+                    JCheckBoxMenuItem(
+                        "Serve MCP Endpoint",
+                        isMcpEndpointServed(service.getMcpEnabled(), extensions::serve),
+                    )
+                serveMcpEndpoint.mnemonic = 'M'.code
+                serveMcpEndpoint.toolTipText = MCP_ENDPOINT_TOOLTIP
+                serveMcpEndpoint.addActionListener {
+                    this@App.switchMcpEndpoint(serveMcpEndpoint)
+                }
+                add(serveMcpEndpoint)
+
+                addSeparator()
+
                 val exitItem = JMenuItem("Exit")
                 exitItem.mnemonic = 'X'.code
                 exitItem.accelerator = KeyStroke.getKeyStroke("alt F4")
@@ -283,6 +301,19 @@ public class App {
         homePanel.refreshRecentDumps()
     }
 
+    private fun switchMcpEndpoint(item: JCheckBoxMenuItem) {
+        val switch =
+            switchMcpEndpoint(item.isSelected, extensions::serve, extensions::stopServing, service::setMcpEnabled)
+        item.isSelected = switch.served
+        val failure = switch.failure ?: return
+        JOptionPane.showMessageDialog(
+            frame,
+            failure,
+            "MCP Endpoint",
+            JOptionPane.ERROR_MESSAGE,
+        )
+    }
+
     private fun openBinaryLogsFolder() {
         openFolder(BINARY_PATH, "You have not created any logs yet.")
     }

gui/proxy-tool/src/main/kotlin/net/rsprox/gui/McpEndpointNotice.kt

@@ -0,0 +1,43 @@
+package net.rsprox.gui
+
+internal const val MCP_ENDPOINT_TOOLTIP: String =
+    "No password: any program on this computer can read every session's packets, chat included. " +
+        "While off, nothing is served; sessions of clients launched in this run are kept in memory and " +
+        "listed again when it is turned back on."
+
+internal data class McpEndpointSwitch(
+    val served: Boolean,
+    val failure: String?,
+)
+
+/**
+ * Whether the item starts ticked. An endpoint that is on was served at start-up, unless its port was
+ * taken then, so it is asked once more. The saved choice is left alone, so the next start tries again.
+ */
+internal fun isMcpEndpointServed(
+    enabled: Boolean,
+    serve: () -> String?,
+): Boolean = enabled && serve() == null
+
+/**
+ * Turns the endpoint on or off at once, and saves the choice once it holds. An endpoint that cannot be
+ * served stays off with nothing saved, and the result says why.
+ */
+internal fun switchMcpEndpoint(
+    enabled: Boolean,
+    serve: () -> String?,
+    stopServing: () -> Unit,
+    save: (Boolean) -> Unit,
+): McpEndpointSwitch {
+    if (!enabled) {
+        stopServing()
+        save(false)
+        return McpEndpointSwitch(served = false, failure = null)
+    }
+    val refusal = serve()
+    if (refusal != null) {
+        return McpEndpointSwitch(served = false, failure = refusal.replace(". ", ".\n"))
+    }
+    save(true)
+    return McpEndpointSwitch(served = true, failure = null)
+}

gui/proxy-tool/src/main/kotlin/net/rsprox/gui/ProxyToolGui.kt

@@ -1,5 +1,6 @@
 package net.rsprox.gui
 
+import net.rsprox.proxy.ProxyExtension
 import java.util.Locale
 import javax.swing.ImageIcon
 import javax.swing.SwingUtilities
@@ -28,6 +29,7 @@ public fun main(args: Array<String>) {
     App.service.start(rspsJavConfigUrl, rspsModulus) { percentage, actionText, subActionText, progressText ->
         SplashScreen.stage(percentage, actionText, subActionText, progressText)
     }
+    val extensions = ProxyExtension.startAll(App.service)
     SplashScreen.stop()
     SwingUtilities.invokeLater {
         // Disable icons in all trees.
@@ -42,7 +44,7 @@ public fun main(args: Array<String>) {
         // This ensures that the theme you see is the same on initial boot as well as swapping back and forth
         AppThemes.applyThemeEdt(App.service.getAppTheme())
 
-        val app = App()
+        val app = App(extensions)
         app.init()
         app.start()
     }

gui/proxy-tool/src/test/kotlin/net/rsprox/gui/McpEndpointNoticeTest.kt

@@ -0,0 +1,68 @@
+package net.rsprox.gui
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class McpEndpointNoticeTest {
+    private val calls = ArrayList<String>()
+
+    private fun switch(
+        enabled: Boolean,
+        refusal: String? = null,
+    ): McpEndpointSwitch =
+        switchMcpEndpoint(
+            enabled,
+            serve = {
+                calls += "serve"
+                refusal
+            },
+            stopServing = { calls += "stop serving" },
+            save = { calls += "save $it" },
+        )
+
+    @Test
+    fun `turning the endpoint on serves it at once and then saves the choice`() {
+        assertEquals(McpEndpointSwitch(served = true, failure = null), switch(enabled = true))
+        assertEquals(listOf("serve", "save true"), calls)
+    }
+
+    @Test
+    fun `turning the endpoint off stops serving it at once and then saves the choice`() {
+        assertEquals(McpEndpointSwitch(served = false, failure = null), switch(enabled = false))
+        assertEquals(listOf("stop serving", "save false"), calls)
+    }
+
+    @Test
+    fun `an endpoint that cannot be served stays off, saves nothing and says why with a sentence to a line`() {
+        val refusal =
+            "The MCP endpoint is not served: 127.0.0.1:43999 cannot be bound (Address already in use). " +
+                "Another rsprox may hold it. Close that one."
+
+        assertEquals(
+            McpEndpointSwitch(
+                served = false,
+                failure =
+                    "The MCP endpoint is not served: 127.0.0.1:43999 cannot be bound (Address already in use).\n" +
+                        "Another rsprox may hold it.\n" +
+                        "Close that one.",
+            ),
+            switch(enabled = true, refusal),
+        )
+        assertEquals(listOf("serve"), calls)
+    }
+
+    @Test
+    fun `two clicks in a row leave the endpoint as the second click says`() {
+        switch(enabled = true)
+
+        assertEquals(McpEndpointSwitch(served = false, failure = null), switch(enabled = false))
+        assertEquals(listOf("serve", "save true", "stop serving", "save false"), calls)
+    }
+
+    @Test
+    fun `the item starts ticked only for an endpoint that is on and served`() {
+        assertEquals(true, isMcpEndpointServed(enabled = true) { null })
+        assertEquals(false, isMcpEndpointServed(enabled = true) { "127.0.0.1:43999 cannot be bound" })
+        assertEquals(false, isMcpEndpointServed(enabled = false) { error("an endpoint that is off is not served") })
+    }
+}