Add Terminal Shell Command Handler

With the TerminalShellCommandHandler interface it is possible to connect
Intellij to a custom ethersync daemon command.

Author: schrieveslaach

build.gradle.kts

@@ -9,16 +9,11 @@ version = "1.0-SNAPSHOT"
 
 repositories {
    mavenCentral()
-   maven {
-      url = uri("https://jitpack.io")
-   }
 }
 
 dependencies {
-   implementation("com.github.Osiris-Team:jansi:2.4.6")
    implementation("org.eclipse.lsp4j:org.eclipse.lsp4j:0.23.1")
    implementation("org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:0.23.1")
-   implementation("org.jsoup:jsoup:1.18.3")
 }
 
 // Configure Gradle IntelliJ Plugin

src/main/kotlin/io/github/ethersync/EthersyncService.kt

@@ -2,5 +2,7 @@ package io.github.ethersync
 
 interface EthersyncService {
 
-   fun connectToPeer(peer: String)
+   fun start(peer: String?)
+
+   fun startWithCustomCommandLine(commandLine: String)
 }

src/main/kotlin/io/github/ethersync/EthersyncServiceImpl.kt

@@ -3,7 +3,6 @@ package io.github.ethersync
 import com.intellij.execution.configurations.GeneralCommandLine
 import com.intellij.execution.process.ColoredProcessHandler
 import com.intellij.execution.process.ProcessEvent
-import com.intellij.execution.process.ProcessHandler
 import com.intellij.execution.process.ProcessListener
 import com.intellij.execution.ui.ConsoleView
 import com.intellij.openapi.components.Service
@@ -45,7 +44,7 @@ class EthersyncServiceImpl(
 )  : EthersyncService {
 
    private var launcher: Launcher<RemoteEthersyncClientProtocol>? = null
-   private var daemonProcess: ProcessHandler? = null
+   private var daemonProcess: ColoredProcessHandler? = null
    private var clientProcess: Process? = null
 
    private val changetracker: Changetracker = Changetracker(project, cs)
@@ -99,36 +98,64 @@ class EthersyncServiceImpl(
       }
       daemonProcess?.let {
          it.detachProcess()
-         it.destroyProcess()
+         it.process.destroy()
+         it.process.awaitExit()
          daemonProcess = null
       }
       changetracker.clear()
       cursortracker.clear()
    }
 
-   override fun connectToPeer(peer: String) {
-      val projectDirectory = File(project.basePath!!)
-      val ethersyncDirectory = File(projectDirectory, ".ethersync")
+   override fun start(peer: String?) {
       val socket = "ethersync-%s-socket".format(project.name)
 
-      if (!ethersyncDirectory.exists()) {
-         LOG.debug("Creating ethersync directory")
-         ethersyncDirectory.mkdir()
-      }
-
       val cmd = GeneralCommandLine(AppSettings.getInstance().state.ethersyncBinaryPath)
-      cmd.workDirectory = projectDirectory
+
       cmd.addParameter("daemon")
-      if (peer.isNotBlank()) {
-         cmd.addParameter("--peer")
-         cmd.addParameter(peer)
+      peer?.let {
+         if (peer.isNotBlank()) {
+            cmd.addParameter("--peer")
+            cmd.addParameter(peer)
+         }
       }
       cmd.addParameter("--socket-name")
       cmd.addParameter(socket)
 
+      launchDaemon(cmd)
+   }
+
+   override fun startWithCustomCommandLine(commandLine: String) {
+      // TODO: splitting by " " is probably insufficient if there is an argument with spaces in it…
+      val cmd = GeneralCommandLine(commandLine.split(" "))
+
+      launchDaemon(cmd)
+   }
+
+   private fun launchDaemon(cmd: GeneralCommandLine) {
+      val projectDirectory = File(project.basePath!!)
+      val ethersyncDirectory = File(projectDirectory, ".ethersync")
+      cmd.workDirectory = projectDirectory
+
+      var socket: String? = null
+      if (cmd.parametersList.hasParameter("--socket-name") || cmd.parametersList.hasParameter("-s")) {
+         for (i in 0..(cmd.parametersList.parametersCount - 1)) {
+            val name = cmd.parametersList[i]
+
+            if (name == "--socket-name" || name == "-s") {
+               socket = cmd.parametersList[i + 1]
+               break
+            }
+         }
+      }
+
       cs.launch {
          shutdown()
 
+         if (!ethersyncDirectory.exists()) {
+            LOG.debug("Creating ethersync directory")
+            ethersyncDirectory.mkdir()
+         }
+
          withUiContext {
             daemonProcess = ColoredProcessHandler(cmd)
 
@@ -175,12 +202,21 @@ class EthersyncServiceImpl(
       }
    }
 
-   private fun launchEthersyncClient(socket: String, projectDirectory: File) {
+   private fun launchEthersyncClient(socket: String?, projectDirectory: File) {
       if (clientProcess != null) {
          return
       }
 
       cs.launch {
+         val cmd = GeneralCommandLine(AppSettings.getInstance().state.ethersyncBinaryPath)
+         cmd.workDirectory = projectDirectory
+         cmd.addParameter("client")
+
+         socket?.let {
+            cmd.addParameter("--socket-name")
+            cmd.addParameter(it)
+         }
+
          LOG.info("Starting ethersync client")
          // TODO: try catch not existing binary
          val clientProcessBuilder = ProcessBuilder(

src/main/kotlin/io/github/ethersync/ConnectToPeerAction.kt renamed to src/main/kotlin/io/github/ethersync/StartEthersyncDaemonAction.kt

@@ -5,22 +5,22 @@ import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.components.service
 import com.intellij.openapi.ui.Messages
 
-class ConnectToPeerAction : AnAction() {
+class StartEthersyncDaemonAction : AnAction() {
 
    override fun actionPerformed(e: AnActionEvent) {
       val project = e.project ?: return
 
       val address = Messages.showInputDialog(
          project,
-         "Provide ethersync peer address",
+         "Provide ethersync peer address. Leave empty if you want to host a new session.",
          "Peer Address",
          Icons.PluginIcon
       )
 
       if (address != null) {
          val service = project.service<EthersyncService>()
 
-         service.connectToPeer(address)
+         service.start(address)
       }
    }
 }

src/main/kotlin/io/github/ethersync/StartEthersyncDaemonTerminalShellCommandHandler.kt

@@ -0,0 +1,38 @@
+package io.github.ethersync
+
+import com.intellij.execution.Executor
+import com.intellij.openapi.components.service
+import com.intellij.openapi.project.Project
+import com.intellij.terminal.TerminalShellCommandHandler
+import io.github.ethersync.settings.AppSettings
+
+class StartEthersyncDaemonTerminalShellCommandHandler : TerminalShellCommandHandler {
+    override fun execute(
+        project: Project,
+        workingDirectory: String?,
+        localSession: Boolean,
+        command: String,
+        executor: Executor
+    ): Boolean {
+        workingDirectory?.let {
+            if (project.basePath != it) {
+                return false
+            }
+        }
+        val ethersyncService = project.service<EthersyncService>()
+        ethersyncService.startWithCustomCommandLine(command)
+        return true
+    }
+
+    override fun matches(project: Project, workingDirectory: String?, localSession: Boolean, command: String): Boolean {
+        val ethersyncBinary = AppSettings.getInstance().state.ethersyncBinaryPath
+
+        if (!command.startsWith(ethersyncBinary)) {
+            return false
+        }
+
+        val rest = command.substring(ethersyncBinary.length).trim()
+
+        return rest.startsWith("daemon")
+    }
+}

src/main/kotlin/io/github/ethersync/sync/Changetracker.kt

@@ -27,6 +27,7 @@ class Changetracker(
    private val cs: CoroutineScope,
 ) : DocumentListener {
 
+   // TODO: remove because that seems brittle…
    private val ignoreChangeEvent = AtomicBoolean(false)
 
    private data class FileRevision(

src/main/resources/META-INF/plugin.xml

@@ -28,14 +28,17 @@
            id="ethersync"
            icon="io.github.ethersync.Icons.PluginIcon"
            factoryClass="io.github.ethersync.EthersyncToolWindowFactory"/>
+
+      <terminal.shellCommandHandler
+           implementation="io.github.ethersync.StartEthersyncDaemonTerminalShellCommandHandler"/>
    </extensions>
 
    <actions>
       <action
-         id="ConnectToPeerAction"
-         class="io.github.ethersync.ConnectToPeerAction"
-         text="Connect to Ethersync Peer"
-         description="Connect to a running ethersync daemon"
+         id="StartEthersyncDaemon"
+         class="io.github.ethersync.StartEthersyncDaemonAction"
+         text="Code with Ethersync"
+         description="Connect to a running ethersync daemon or start a new peer"
          icon="io.github.ethersync.Icons.PluginIcon">
          <add-to-group group-id="ToolsMenu" anchor="first"/>
       </action>