Merge branch 'wip/bumpsbt' into wip/merge-1.1.x

2018-03-27 09:12:01 -04:00 · 2018-03-27 09:12:01 -04:00 · c2837c7714
parent ca874d5d5f 1b77b35333
commit c2837c7714
64 changed files with 352 additions and 112 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -188,10 +188,12 @@ sbt:sbtRoot> publishLocal

 ### Using the locally built sbt

-To use the locally built sbt, set the version in `build.properties` file to `1.$MINOR.$PATCH-SNAPSHOT`.
+The `publishLocal` above will build and publish version `1.$MINOR.$PATCH-SNAPSHOT` (e.g. 1.1.2-SNAPSHOT) to your local ivy repository.
+
+To use the locally built sbt, set the version in `build.properties` file in your project to `1.$MINOR.$PATCH-SNAPSHOT` then launch `sbt` (this can be the `sbt` launcher installed in your machine).

 ```
-$ cd ../hello
+$ cd $YOUR_OWN_PROJECT
 $ sbt
 > compile
 ```
--- a/build.sbt
+++ b/build.sbt
@ -80,7 +80,7 @@ val mimaSettings = Def settings (
  mimaPreviousArtifacts := {
    Seq(
      "1.0.0", "1.0.1", "1.0.2", "1.0.3", "1.0.4",
-      "1.1.0", "1.1.1",
+      "1.1.0", "1.1.1", "1.1.2",
    ).map { v =>
      organization.value % moduleName.value % v cross (if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled)
    }.toSet
@ -220,9 +220,26 @@ lazy val testingProj = (project in file("testing"))
    mimaSettings,
    mimaBinaryIssueFilters ++= Seq(
      // private[sbt]
-      ProblemFilters.exclude[IncompatibleMethTypeProblem]("sbt.TestStatus.write"),
-      ProblemFilters.exclude[IncompatibleResultTypeProblem]("sbt.TestStatus.read"),
-    ),
+      exclude[IncompatibleMethTypeProblem]("sbt.TestStatus.write"),
+      exclude[IncompatibleResultTypeProblem]("sbt.TestStatus.read"),
+
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupErrorEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupErrorEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.StartTestGroupEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.StartTestGroupEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestInitEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy$default$1"),
+    )
  )
  .configure(addSbtIO, addSbtCompilerClasspath, addSbtUtilLogging)

@ -271,6 +288,17 @@ lazy val runProj = (project in file("run"))
      baseDirectory.value / "src" / "main" / "contraband-scala",
    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy$default$*"),
+    )
  )
  .configure(addSbtIO, addSbtUtilLogging, addSbtCompilerClasspath)

@ -358,6 +386,31 @@ lazy val protocolProj = (project in file("protocol"))
    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
    contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
    mimaSettings,
+    mimaBinaryIssueFilters ++= Seq(
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$2"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy$default$1"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy$default$*"),
+
+      // ignore missing methods in sbt.internal
+      exclude[DirectMissingMethodProblem]("sbt.internal.*"),
+    )
  )
  .configure(addSbtUtilLogging)

@ -387,8 +440,15 @@ lazy val commandProj = (project in file("main-command"))
      // Replace nailgun socket stuff
      exclude[MissingClassProblem]("sbt.internal.NG*"),
      exclude[MissingClassProblem]("sbt.internal.ReferenceCountedFileDescriptor"),
+
      // made private[sbt] method private[this]
      exclude[DirectMissingMethodProblem]("sbt.State.handleException"),
+
+      // copy method was never meant to be public
+      exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy$default$*"),
+      exclude[DirectMissingMethodProblem]("sbt.Exec.copy"),
+      exclude[DirectMissingMethodProblem]("sbt.Exec.copy$default$*"),
    ),
    unmanagedSources in (Compile, headerCreate) := {
      val old = (unmanagedSources in (Compile, headerCreate)).value
--- a/main-command/src/main/contraband-scala/sbt/CommandSource.scala
+++ b/main-command/src/main/contraband-scala/sbt/CommandSource.scala
@ -19,7 +19,7 @@ final class CommandSource private (
  override def toString: String = {
    "CommandSource(" + channelName + ")"
  }
-  protected[this] def copy(channelName: String = channelName): CommandSource = {
+  private[this] def copy(channelName: String = channelName): CommandSource = {
    new CommandSource(channelName)
  }
  def withChannelName(channelName: String): CommandSource = {
--- a/main-command/src/main/contraband-scala/sbt/Exec.scala
+++ b/main-command/src/main/contraband-scala/sbt/Exec.scala
@ -21,7 +21,7 @@ final class Exec private (
  override def toString: String = {
    "Exec(" + commandLine + ", " + execId + ", " + source + ")"
  }
-  protected[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId, source: Option[sbt.CommandSource] = source): Exec = {
+  private[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId, source: Option[sbt.CommandSource] = source): Exec = {
    new Exec(commandLine, execId, source)
  }
  def withCommandLine(commandLine: String): Exec = {
@ -42,8 +42,8 @@ final class Exec private (
 }
 object Exec {
  def newExecId: String = java.util.UUID.randomUUID.toString
-  def apply(commandLine: String, source: Option[sbt.CommandSource]): Exec = new Exec(commandLine, None, source)
-  def apply(commandLine: String, source: sbt.CommandSource): Exec = new Exec(commandLine, None, Option(source))
+  def apply(commandLine: String, source: Option[sbt.CommandSource]): Exec = new Exec(commandLine, source)
+  def apply(commandLine: String, source: sbt.CommandSource): Exec = new Exec(commandLine, Option(source))
  def apply(commandLine: String, execId: Option[String], source: Option[sbt.CommandSource]): Exec = new Exec(commandLine, execId, source)
  def apply(commandLine: String, execId: String, source: sbt.CommandSource): Exec = new Exec(commandLine, Option(execId), Option(source))
 }
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@ -635,12 +635,15 @@ object Defaults extends BuildCommon {
      if (ScalaInstance.isDotty(scalaVersion.value))
        file(ScalaArtifacts.dottyID(binVersion))
      else file(ScalaArtifacts.CompilerID)
-    new ScalaInstance(scalaVersion.value,
-                      makeClassLoader(state.value)(allJars.toList),
-                      libraryJar,
-                      compilerJar,
-                      allJars.toArray,
-                      None)
+    new ScalaInstance(
+      scalaVersion.value,
+      makeClassLoader(state.value)(allJars.toList),
+      makeClassLoader(state.value)(List(libraryJar)),
+      libraryJar,
+      compilerJar,
+      allJars.toArray,
+      None
+    )
  }
  def scalaInstanceFromHome(dir: File): Initialize[Task[ScalaInstance]] = Def.task {
    ScalaInstance(dir)(makeClassLoader(state.value))
--- a/main/src/main/scala/sbt/MainLoop.scala
+++ b/main/src/main/scala/sbt/MainLoop.scala
@ -18,6 +18,7 @@ import scala.util.control.NonFatal
 import sbt.io.{ IO, Using }
 import sbt.internal.util.{ ErrorHandling, GlobalLogBacking }
 import sbt.internal.util.complete.Parser
+import sbt.internal.langserver.ErrorCodes
 import sbt.util.Logger
 import sbt.protocol._

@ -154,13 +155,63 @@ object MainLoop {
        state.log error errMsg
        state.fail
    }
-    StandardMain.exchange publishEventMessage ExecStatusEvent(
+    val doneEvent = ExecStatusEvent(
      "Done",
      channelName,
      exec.execId,
-      newState.remainingCommands.toVector map (_.commandLine))
+      newState.remainingCommands.toVector map (_.commandLine),
+      exitCode(newState, state),
+    )
+    if (doneEvent.execId.isDefined) { // send back a response or error
+      import sbt.protocol.codec.JsonProtocol._
+      StandardMain.exchange publishEvent doneEvent
+    } else { // send back a notification
+      StandardMain.exchange publishEventMessage doneEvent
+    }
    newState
  }

  def logFullException(e: Throwable, log: Logger): Unit = State.logFullException(e, log)
+
+  private[this] type ExitCode = Option[Long]
+  private[this] object ExitCode {
+    def apply(n: Long): ExitCode = Option(n)
+    val Success: ExitCode = ExitCode(0)
+    val Unknown: ExitCode = None
+  }
+
+  private[this] def exitCode(state: State, prevState: State): ExitCode = {
+    exitCodeFromStateNext(state) match {
+      case ExitCode.Success => exitCodeFromStateOnFailure(state, prevState)
+      case x                => x
+    }
+  }
+
+  // State's "next" field indicates the next action for the command processor to take
+  // we'll use that to determine if the command failed
+  private[this] def exitCodeFromStateNext(state: State): ExitCode = {
+    state.next match {
+      case State.Continue       => ExitCode.Success
+      case State.ClearGlobalLog => ExitCode.Success
+      case State.KeepLastLog    => ExitCode.Success
+      case ret: State.Return =>
+        ret.result match {
+          case exit: xsbti.Exit  => ExitCode(exit.code().toLong)
+          case _: xsbti.Continue => ExitCode.Success
+          case _: xsbti.Reboot   => ExitCode.Success
+          case x =>
+            val clazz = if (x eq null) "" else " (class: " + x.getClass + ")"
+            state.log debug s"Unknown main result: $x$clazz"
+            ExitCode.Unknown
+        }
+    }
+  }
+
+  // the shell command specifies an onFailure so that if an exception is thrown
+  // it's handled by executing the shell again, instead of the state failing
+  // so we also use that to indicate that the execution failed
+  private[this] def exitCodeFromStateOnFailure(state: State, prevState: State): ExitCode =
+    if (prevState.onFailure.isDefined && state.onFailure.isEmpty) ExitCode(ErrorCodes.UnknownError)
+    else ExitCode.Success
+
 }
--- a/main/src/main/scala/sbt/TemplateCommand.scala
+++ b/main/src/main/scala/sbt/TemplateCommand.scala
@ -27,12 +27,22 @@ private[sbt] object TemplateCommandUtil {
  private def templateCommandParser: Parser[Seq[String]] =
    (token(Space) ~> repsep(StringBasic, token(Space))) | (token(EOF) map (_ => Nil))

-  private def runTemplate(state: State, inputArg: Seq[String]): State = {
+  private def runTemplate(s0: State, inputArg: Seq[String]): State = {
+    import BuildPaths._
+    val extracted0 = (Project extract s0)
+    val globalBase = getGlobalBase(s0)
+    val stagingDirectory = getStagingDirectory(s0, globalBase).getCanonicalFile
+    val templateStage = stagingDirectory / "new"
+    // This moves the target directory to a staging directory
+    // https://github.com/sbt/sbt/issues/2835
+    val state = extracted0.appendWithSession(Seq(
+                                               Keys.target := templateStage
+                                             ),
+                                             s0)
    val infos = (state get templateResolverInfos getOrElse Nil).toList
    val log = state.globalLogging.full
    val extracted = (Project extract state)
    val (s2, ivyConf) = extracted.runTask(Keys.ivyConfiguration, state)
-    val globalBase = BuildPaths.getGlobalBase(state)
    val scalaModuleInfo = extracted.get(Keys.scalaModuleInfo in Keys.updateSbtClassifiers)
    val arguments = inputArg.toList ++
      (state.remainingCommands match {
--- a/main/src/main/scala/sbt/internal/LogManager.scala
+++ b/main/src/main/scala/sbt/internal/LogManager.scala
@ -229,8 +229,13 @@ object LogManager {
  //     s
  //   }

-  def setGlobalLogLevel(s: State, level: Level.Value): State =
-    s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
+  def setGlobalLogLevel(s: State, level: Level.Value): State = {
+    val s1 = s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
+    val gl = s1.globalLogging
+    LogExchange.unbindLoggerAppenders(gl.full.name)
+    LogExchange.bindLoggerAppenders(gl.full.name, (gl.backed -> level) :: Nil)
+    s1
+  }

  // This is the default implementation for the relay appender
  val defaultRelay: Unit => Appender = _ => defaultRelayImpl
--- a/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
+++ b/main/src/main/scala/sbt/internal/server/LanguageServerProtocol.scala
@ -76,7 +76,7 @@ private[sbt] object LanguageServerProtocol {
          }
        }, {
          case n: JsonRpcNotificationMessage if n.method == "textDocument/didSave" =>
-            appendExec(Exec(";compile; collectAnalyses", None, Some(CommandSource(name))))
+            appendExec(Exec(";Test/compile; collectAnalyses", None, Some(CommandSource(name))))
            ()
        }
      )
--- a/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
+++ b/main/src/main/scala/sbt/internal/server/NetworkChannel.scala
@ -248,7 +248,13 @@ final class NetworkChannel(val name: String,
    if (isLanguageServerProtocol) {
      event match {
        case entry: StringEvent => logMessage(entry.level, entry.message)
-        case _                  => jsonRpcRespond(event, execId)
+        case entry: ExecStatusEvent =>
+          entry.exitCode match {
+            case None           => jsonRpcRespond(event, entry.execId)
+            case Some(0)        => jsonRpcRespond(event, entry.execId)
+            case Some(exitCode) => jsonRpcRespondError(entry.execId, exitCode, "")
+          }
+        case _ => jsonRpcRespond(event, execId)
      }
    } else {
      contentType match {
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@ -9,9 +9,9 @@ object Dependencies {

  // sbt modules
  private val ioVersion = "1.1.4"
-  private val utilVersion = "1.1.2"
-  private val lmVersion = "1.1.3"
-  private val zincVersion = "1.1.1"
+  private val utilVersion = "1.1.3"
+  private val lmVersion = "1.1.4"
+  private val zincVersion = "1.1.3"

  private val sbtIO = "org.scala-sbt" %% "io" % ioVersion

@ -26,8 +26,8 @@ object Dependencies {
  private val libraryManagementCore = "org.scala-sbt" %% "librarymanagement-core" % lmVersion
  private val libraryManagementIvy = "org.scala-sbt" %% "librarymanagement-ivy" % lmVersion

-  val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.0.2"
-  val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.2"
+  val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.0.3"
+  val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.3"
  val testInterface = "org.scala-sbt" % "test-interface" % "1.0"
  val ipcSocket = "org.scala-sbt.ipcsocket" % "ipcsocket" % "1.0.0"

--- a/project/build.properties
+++ b/project/build.properties
@ -1 +1 @@
-sbt.version=1.1.1
+sbt.version=1.1.2
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@ -2,7 +2,7 @@ scalaVersion := "2.12.4"
 scalacOptions ++= Seq("-feature", "-language:postfixOps")

 addSbtPlugin("org.scala-sbt"     % "sbt-houserules"  % "0.3.5")
-addSbtPlugin("org.scala-sbt"     % "sbt-contraband"  % "0.3.2")
+addSbtPlugin("org.scala-sbt"     % "sbt-contraband"  % "0.4.0")
 addSbtPlugin("de.heikoseeberger" % "sbt-header"      % "3.0.2")
 addSbtPlugin("com.eed3si9n"      % "sbt-buildinfo"   % "0.8.0")
 addSbtPlugin("com.lightbend"     % "sbt-whitesource" % "0.1.9")
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/ClientCapabilities.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/ClientCapabilities.scala
@ -18,7 +18,7 @@ override def hashCode: Int = {
 override def toString: String = {
  "ClientCapabilities()"
 }
-protected[this] def copy(): ClientCapabilities = {
+private[this] def copy(): ClientCapabilities = {
  new ClientCapabilities()
 }

--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/Diagnostic.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Diagnostic.scala
@ -38,7 +38,7 @@ final class Diagnostic private (
  override def toString: String = {
    "Diagnostic(" + range + ", " + severity + ", " + code + ", " + source + ", " + message + ")"
  }
-  protected[this] def copy(range: sbt.internal.langserver.Range = range, severity: Option[Long] = severity, code: Option[String] = code, source: Option[String] = source, message: String = message): Diagnostic = {
+  private[this] def copy(range: sbt.internal.langserver.Range = range, severity: Option[Long] = severity, code: Option[String] = code, source: Option[String] = source, message: String = message): Diagnostic = {
    new Diagnostic(range, severity, code, source, message)
  }
  def withRange(range: sbt.internal.langserver.Range): Diagnostic = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeParams.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeParams.scala
@ -25,7 +25,7 @@ final class InitializeParams private (
  override def toString: String = {
    "InitializeParams(" + processId + ", " + rootPath + ", " + rootUri + ", " + initializationOptions + ", " + capabilities + ", " + trace + ")"
  }
-  protected[this] def copy(processId: Option[Long] = processId, rootPath: Option[String] = rootPath, rootUri: Option[String] = rootUri, initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = initializationOptions, capabilities: Option[sbt.internal.langserver.ClientCapabilities] = capabilities, trace: Option[String] = trace): InitializeParams = {
+  private[this] def copy(processId: Option[Long] = processId, rootPath: Option[String] = rootPath, rootUri: Option[String] = rootUri, initializationOptions: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = initializationOptions, capabilities: Option[sbt.internal.langserver.ClientCapabilities] = capabilities, trace: Option[String] = trace): InitializeParams = {
    new InitializeParams(processId, rootPath, rootUri, initializationOptions, capabilities, trace)
  }
  def withProcessId(processId: Option[Long]): InitializeParams = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeResult.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/InitializeResult.scala
@ -20,7 +20,7 @@ final class InitializeResult private (
  override def toString: String = {
    "InitializeResult(" + capabilities + ")"
  }
-  protected[this] def copy(capabilities: sbt.internal.langserver.ServerCapabilities = capabilities): InitializeResult = {
+  private[this] def copy(capabilities: sbt.internal.langserver.ServerCapabilities = capabilities): InitializeResult = {
    new InitializeResult(capabilities)
  }
  def withCapabilities(capabilities: sbt.internal.langserver.ServerCapabilities): InitializeResult = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/Location.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Location.scala
@ -21,7 +21,7 @@ final class Location private (
  override def toString: String = {
    "Location(" + uri + ", " + range + ")"
  }
-  protected[this] def copy(uri: String = uri, range: sbt.internal.langserver.Range = range): Location = {
+  private[this] def copy(uri: String = uri, range: sbt.internal.langserver.Range = range): Location = {
    new Location(uri, range)
  }
  def withUri(uri: String): Location = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/LogMessageParams.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/LogMessageParams.scala
@ -22,7 +22,7 @@ final class LogMessageParams private (
  override def toString: String = {
    "LogMessageParams(" + `type` + ", " + message + ")"
  }
-  protected[this] def copy(`type`: Long = `type`, message: String = message): LogMessageParams = {
+  private[this] def copy(`type`: Long = `type`, message: String = message): LogMessageParams = {
    new LogMessageParams(`type`, message)
  }
  def withType(`type`: Long): LogMessageParams = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/Position.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Position.scala
@ -26,7 +26,7 @@ final class Position private (
  override def toString: String = {
    "Position(" + line + ", " + character + ")"
  }
-  protected[this] def copy(line: Long = line, character: Long = character): Position = {
+  private[this] def copy(line: Long = line, character: Long = character): Position = {
    new Position(line, character)
  }
  def withLine(line: Long): Position = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/PublishDiagnosticsParams.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/PublishDiagnosticsParams.scala
@ -23,7 +23,7 @@ final class PublishDiagnosticsParams private (
  override def toString: String = {
    "PublishDiagnosticsParams(" + uri + ", " + diagnostics + ")"
  }
-  protected[this] def copy(uri: String = uri, diagnostics: Vector[sbt.internal.langserver.Diagnostic] = diagnostics): PublishDiagnosticsParams = {
+  private[this] def copy(uri: String = uri, diagnostics: Vector[sbt.internal.langserver.Diagnostic] = diagnostics): PublishDiagnosticsParams = {
    new PublishDiagnosticsParams(uri, diagnostics)
  }
  def withUri(uri: String): PublishDiagnosticsParams = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/Range.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/Range.scala
@ -26,7 +26,7 @@ final class Range private (
  override def toString: String = {
    "Range(" + start + ", " + end + ")"
  }
-  protected[this] def copy(start: sbt.internal.langserver.Position = start, end: sbt.internal.langserver.Position = end): Range = {
+  private[this] def copy(start: sbt.internal.langserver.Position = start, end: sbt.internal.langserver.Position = end): Range = {
    new Range(start, end)
  }
  def withStart(start: sbt.internal.langserver.Position): Range = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/SaveOptions.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/SaveOptions.scala
@ -20,7 +20,7 @@ final class SaveOptions private (
  override def toString: String = {
    "SaveOptions(" + includeText + ")"
  }
-  protected[this] def copy(includeText: Option[Boolean] = includeText): SaveOptions = {
+  private[this] def copy(includeText: Option[Boolean] = includeText): SaveOptions = {
    new SaveOptions(includeText)
  }
  def withIncludeText(includeText: Option[Boolean]): SaveOptions = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/SbtExecParams.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/SbtExecParams.scala
@ -20,7 +20,7 @@ final class SbtExecParams private (
  override def toString: String = {
    "SbtExecParams(" + commandLine + ")"
  }
-  protected[this] def copy(commandLine: String = commandLine): SbtExecParams = {
+  private[this] def copy(commandLine: String = commandLine): SbtExecParams = {
    new SbtExecParams(commandLine)
  }
  def withCommandLine(commandLine: String): SbtExecParams = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/ServerCapabilities.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/ServerCapabilities.scala
@ -23,7 +23,7 @@ final class ServerCapabilities private (
  override def toString: String = {
    "ServerCapabilities(" + textDocumentSync + ", " + hoverProvider + ", " + definitionProvider + ")"
  }
-  protected[this] def copy(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions] = textDocumentSync, hoverProvider: Option[Boolean] = hoverProvider, definitionProvider: Option[Boolean] = definitionProvider): ServerCapabilities = {
+  private[this] def copy(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions] = textDocumentSync, hoverProvider: Option[Boolean] = hoverProvider, definitionProvider: Option[Boolean] = definitionProvider): ServerCapabilities = {
    new ServerCapabilities(textDocumentSync, hoverProvider, definitionProvider)
  }
  def withTextDocumentSync(textDocumentSync: Option[sbt.internal.langserver.TextDocumentSyncOptions]): ServerCapabilities = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentIdentifier.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentIdentifier.scala
@ -21,7 +21,7 @@ final class TextDocumentIdentifier private (
  override def toString: String = {
    "TextDocumentIdentifier(" + uri + ")"
  }
-  protected[this] def copy(uri: String = uri): TextDocumentIdentifier = {
+  private[this] def copy(uri: String = uri): TextDocumentIdentifier = {
    new TextDocumentIdentifier(uri)
  }
  def withUri(uri: String): TextDocumentIdentifier = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParams.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentPositionParams.scala
@ -23,7 +23,7 @@ final class TextDocumentPositionParams private (
  override def toString: String = {
    "TextDocumentPositionParams(" + textDocument + ", " + position + ")"
  }
-  protected[this] def copy(textDocument: sbt.internal.langserver.TextDocumentIdentifier = textDocument, position: sbt.internal.langserver.Position = position): TextDocumentPositionParams = {
+  private[this] def copy(textDocument: sbt.internal.langserver.TextDocumentIdentifier = textDocument, position: sbt.internal.langserver.Position = position): TextDocumentPositionParams = {
    new TextDocumentPositionParams(textDocument, position)
  }
  def withTextDocument(textDocument: sbt.internal.langserver.TextDocumentIdentifier): TextDocumentPositionParams = {
--- a/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentSyncOptions.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/langserver/TextDocumentSyncOptions.scala
@ -23,7 +23,7 @@ final class TextDocumentSyncOptions private (
  override def toString: String = {
    "TextDocumentSyncOptions(" + openClose + ", " + change + ", " + willSave + ", " + willSaveWaitUntil + ", " + save + ")"
  }
-  protected[this] def copy(openClose: Option[Boolean] = openClose, change: Option[Long] = change, willSave: Option[Boolean] = willSave, willSaveWaitUntil: Option[Boolean] = willSaveWaitUntil, save: Option[sbt.internal.langserver.SaveOptions] = save): TextDocumentSyncOptions = {
+  private[this] def copy(openClose: Option[Boolean] = openClose, change: Option[Long] = change, willSave: Option[Boolean] = willSave, willSaveWaitUntil: Option[Boolean] = willSaveWaitUntil, save: Option[sbt.internal.langserver.SaveOptions] = save): TextDocumentSyncOptions = {
    new TextDocumentSyncOptions(openClose, change, willSave, willSaveWaitUntil, save)
  }
  def withOpenClose(openClose: Option[Boolean]): TextDocumentSyncOptions = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/InitializeOption.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/InitializeOption.scala
@ -19,7 +19,7 @@ final class InitializeOption private (
  override def toString: String = {
    "InitializeOption(" + token + ")"
  }
-  protected[this] def copy(token: Option[String] = token): InitializeOption = {
+  private[this] def copy(token: Option[String] = token): InitializeOption = {
    new InitializeOption(token)
  }
  def withToken(token: Option[String]): InitializeOption = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcNotificationMessage.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcNotificationMessage.scala
@ -23,7 +23,7 @@ final class JsonRpcNotificationMessage private (
  override def toString: String = {
    s"""JsonRpcNotificationMessage($jsonrpc, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)})"""
  }
-  protected[this] def copy(jsonrpc: String = jsonrpc, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcNotificationMessage = {
+  private[this] def copy(jsonrpc: String = jsonrpc, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcNotificationMessage = {
    new JsonRpcNotificationMessage(jsonrpc, method, params)
  }
  def withJsonrpc(jsonrpc: String): JsonRpcNotificationMessage = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcRequestMessage.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcRequestMessage.scala
@ -25,7 +25,7 @@ final class JsonRpcRequestMessage private (
  override def toString: String = {
    s"""JsonRpcRequestMessage($jsonrpc, $id, $method, ${sbt.protocol.Serialization.compactPrintJsonOpt(params)}})"""
  }
-  protected[this] def copy(jsonrpc: String = jsonrpc, id: String = id, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcRequestMessage = {
+  private[this] def copy(jsonrpc: String = jsonrpc, id: String = id, method: String = method, params: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = params): JsonRpcRequestMessage = {
    new JsonRpcRequestMessage(jsonrpc, id, method, params)
  }
  def withJsonrpc(jsonrpc: String): JsonRpcRequestMessage = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseError.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseError.scala
@ -27,7 +27,7 @@ final class JsonRpcResponseError private (
  override def toString: String = {
    s"""JsonRpcResponseError($code, $message, ${sbt.protocol.Serialization.compactPrintJsonOpt(data)})"""
  }
-  protected[this] def copy(code: Long = code, message: String = message, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): JsonRpcResponseError = {
+  private[this] def copy(code: Long = code, message: String = message, data: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = data): JsonRpcResponseError = {
    new JsonRpcResponseError(code, message, data)
  }
  def withCode(code: Long): JsonRpcResponseError = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseMessage.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/JsonRpcResponseMessage.scala
@ -28,7 +28,7 @@ final class JsonRpcResponseMessage private (
  override def toString: String = {
    s"""JsonRpcResponseMessage($jsonrpc, $id, ${sbt.protocol.Serialization.compactPrintJsonOpt(result)}, $error)"""
  }
-  protected[this] def copy(jsonrpc: String = jsonrpc, id: Option[String] = id, result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = result, error: Option[sbt.internal.protocol.JsonRpcResponseError] = error): JsonRpcResponseMessage = {
+  private[this] def copy(jsonrpc: String = jsonrpc, id: Option[String] = id, result: Option[sjsonnew.shaded.scalajson.ast.unsafe.JValue] = result, error: Option[sbt.internal.protocol.JsonRpcResponseError] = error): JsonRpcResponseMessage = {
    new JsonRpcResponseMessage(jsonrpc, id, result, error)
  }
  def withJsonrpc(jsonrpc: String): JsonRpcResponseMessage = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/PortFile.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/PortFile.scala
@ -26,7 +26,7 @@ final class PortFile private (
  override def toString: String = {
    "PortFile(" + uri + ", " + tokenfilePath + ", " + tokenfileUri + ")"
  }
-  protected[this] def copy(uri: String = uri, tokenfilePath: Option[String] = tokenfilePath, tokenfileUri: Option[String] = tokenfileUri): PortFile = {
+  private[this] def copy(uri: String = uri, tokenfilePath: Option[String] = tokenfilePath, tokenfileUri: Option[String] = tokenfileUri): PortFile = {
    new PortFile(uri, tokenfilePath, tokenfileUri)
  }
  def withUri(uri: String): PortFile = {
--- a/protocol/src/main/contraband-scala/sbt/internal/protocol/TokenFile.scala
+++ b/protocol/src/main/contraband-scala/sbt/internal/protocol/TokenFile.scala
@ -20,7 +20,7 @@ final class TokenFile private (
  override def toString: String = {
    "TokenFile(" + uri + ", " + token + ")"
  }
-  protected[this] def copy(uri: String = uri, token: String = token): TokenFile = {
+  private[this] def copy(uri: String = uri, token: String = token): TokenFile = {
    new TokenFile(uri, token)
  }
  def withUri(uri: String): TokenFile = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/ChannelAcceptedEvent.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ChannelAcceptedEvent.scala
@ -19,7 +19,7 @@ final class ChannelAcceptedEvent private (
  override def toString: String = {
    "ChannelAcceptedEvent(" + channelName + ")"
  }
-  protected[this] def copy(channelName: String = channelName): ChannelAcceptedEvent = {
+  private[this] def copy(channelName: String = channelName): ChannelAcceptedEvent = {
    new ChannelAcceptedEvent(channelName)
  }
  def withChannelName(channelName: String): ChannelAcceptedEvent = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/ExecCommand.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecCommand.scala
@ -21,7 +21,7 @@ final class ExecCommand private (
  override def toString: String = {
    "ExecCommand(" + commandLine + ", " + execId + ")"
  }
-  protected[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId): ExecCommand = {
+  private[this] def copy(commandLine: String = commandLine, execId: Option[String] = execId): ExecCommand = {
    new ExecCommand(commandLine, execId)
  }
  def withCommandLine(commandLine: String): ExecCommand = {
@ -36,7 +36,7 @@ final class ExecCommand private (
 }
 object ExecCommand {
  
-  def apply(commandLine: String): ExecCommand = new ExecCommand(commandLine, None)
+  def apply(commandLine: String): ExecCommand = new ExecCommand(commandLine)
  def apply(commandLine: String, execId: Option[String]): ExecCommand = new ExecCommand(commandLine, execId)
  def apply(commandLine: String, execId: String): ExecCommand = new ExecCommand(commandLine, Option(execId))
 }
--- a/protocol/src/main/contraband-scala/sbt/protocol/ExecStatusEvent.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecStatusEvent.scala
@ -9,22 +9,23 @@ final class ExecStatusEvent private (
  val status: String,
  val channelName: Option[String],
  val execId: Option[String],
-  val commandQueue: Vector[String]) extends sbt.protocol.EventMessage() with Serializable {
-  
+  val commandQueue: Vector[String],
+  val exitCode: Option[Long]) extends sbt.protocol.EventMessage() with Serializable {
  
+  private def this(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String]) = this(status, channelName, execId, commandQueue, None)
  
  override def equals(o: Any): Boolean = o match {
-    case x: ExecStatusEvent => (this.status == x.status) && (this.channelName == x.channelName) && (this.execId == x.execId) && (this.commandQueue == x.commandQueue)
+    case x: ExecStatusEvent => (this.status == x.status) && (this.channelName == x.channelName) && (this.execId == x.execId) && (this.commandQueue == x.commandQueue) && (this.exitCode == x.exitCode)
    case _ => false
  }
  override def hashCode: Int = {
-    37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.ExecStatusEvent".##) + status.##) + channelName.##) + execId.##) + commandQueue.##)
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.protocol.ExecStatusEvent".##) + status.##) + channelName.##) + execId.##) + commandQueue.##) + exitCode.##)
  }
  override def toString: String = {
-    "ExecStatusEvent(" + status + ", " + channelName + ", " + execId + ", " + commandQueue + ")"
+    "ExecStatusEvent(" + status + ", " + channelName + ", " + execId + ", " + commandQueue + ", " + exitCode + ")"
  }
-  protected[this] def copy(status: String = status, channelName: Option[String] = channelName, execId: Option[String] = execId, commandQueue: Vector[String] = commandQueue): ExecStatusEvent = {
-    new ExecStatusEvent(status, channelName, execId, commandQueue)
+  private[this] def copy(status: String = status, channelName: Option[String] = channelName, execId: Option[String] = execId, commandQueue: Vector[String] = commandQueue, exitCode: Option[Long] = exitCode): ExecStatusEvent = {
+    new ExecStatusEvent(status, channelName, execId, commandQueue, exitCode)
  }
  def withStatus(status: String): ExecStatusEvent = {
    copy(status = status)
@ -44,9 +45,17 @@ final class ExecStatusEvent private (
  def withCommandQueue(commandQueue: Vector[String]): ExecStatusEvent = {
    copy(commandQueue = commandQueue)
  }
+  def withExitCode(exitCode: Option[Long]): ExecStatusEvent = {
+    copy(exitCode = exitCode)
+  }
+  def withExitCode(exitCode: Long): ExecStatusEvent = {
+    copy(exitCode = Option(exitCode))
+  }
 }
 object ExecStatusEvent {
  
  def apply(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String]): ExecStatusEvent = new ExecStatusEvent(status, channelName, execId, commandQueue)
  def apply(status: String, channelName: String, execId: String, commandQueue: Vector[String]): ExecStatusEvent = new ExecStatusEvent(status, Option(channelName), Option(execId), commandQueue)
+  def apply(status: String, channelName: Option[String], execId: Option[String], commandQueue: Vector[String], exitCode: Option[Long]): ExecStatusEvent = new ExecStatusEvent(status, channelName, execId, commandQueue, exitCode)
+  def apply(status: String, channelName: String, execId: String, commandQueue: Vector[String], exitCode: Long): ExecStatusEvent = new ExecStatusEvent(status, Option(channelName), Option(execId), commandQueue, Option(exitCode))
 }
--- a/protocol/src/main/contraband-scala/sbt/protocol/ExecutionEvent.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/ExecutionEvent.scala
@ -21,7 +21,7 @@ final class ExecutionEvent private (
  override def toString: String = {
    "ExecutionEvent(" + success + ", " + commandLine + ")"
  }
-  protected[this] def copy(success: String = success, commandLine: String = commandLine): ExecutionEvent = {
+  private[this] def copy(success: String = success, commandLine: String = commandLine): ExecutionEvent = {
    new ExecutionEvent(success, commandLine)
  }
  def withSuccess(success: String): ExecutionEvent = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/InitCommand.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/InitCommand.scala
@ -20,7 +20,7 @@ final class InitCommand private (
  override def toString: String = {
    "InitCommand(" + token + ", " + execId + ")"
  }
-  protected[this] def copy(token: Option[String] = token, execId: Option[String] = execId): InitCommand = {
+  private[this] def copy(token: Option[String] = token, execId: Option[String] = execId): InitCommand = {
    new InitCommand(token, execId)
  }
  def withToken(token: Option[String]): InitCommand = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/LogEvent.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/LogEvent.scala
@ -21,7 +21,7 @@ final class LogEvent private (
  override def toString: String = {
    "LogEvent(" + level + ", " + message + ")"
  }
-  protected[this] def copy(level: String = level, message: String = message): LogEvent = {
+  private[this] def copy(level: String = level, message: String = message): LogEvent = {
    new LogEvent(level, message)
  }
  def withLevel(level: String): LogEvent = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/SettingQuery.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuery.scala
@ -19,7 +19,7 @@ final class SettingQuery private (
  override def toString: String = {
    "SettingQuery(" + setting + ")"
  }
-  protected[this] def copy(setting: String = setting): SettingQuery = {
+  private[this] def copy(setting: String = setting): SettingQuery = {
    new SettingQuery(setting)
  }
  def withSetting(setting: String): SettingQuery = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryFailure.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQueryFailure.scala
@ -19,7 +19,7 @@ final class SettingQueryFailure private (
  override def toString: String = {
    "SettingQueryFailure(" + message + ")"
  }
-  protected[this] def copy(message: String = message): SettingQueryFailure = {
+  private[this] def copy(message: String = message): SettingQueryFailure = {
    new SettingQueryFailure(message)
  }
  def withMessage(message: String): SettingQueryFailure = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala
@ -20,7 +20,7 @@ final class SettingQuerySuccess private (
  override def toString: String = {
    "SettingQuerySuccess(" + value + ", " + contentType + ")"
  }
-  protected[this] def copy(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue = value, contentType: String = contentType): SettingQuerySuccess = {
+  private[this] def copy(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue = value, contentType: String = contentType): SettingQuerySuccess = {
    new SettingQuerySuccess(value, contentType)
  }
  def withValue(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue): SettingQuerySuccess = {
--- a/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala
+++ b/protocol/src/main/contraband-scala/sbt/protocol/codec/ExecStatusEventFormats.scala
@ -15,8 +15,9 @@ implicit lazy val ExecStatusEventFormat: JsonFormat[sbt.protocol.ExecStatusEvent
      val channelName = unbuilder.readField[Option[String]]("channelName")
      val execId = unbuilder.readField[Option[String]]("execId")
      val commandQueue = unbuilder.readField[Vector[String]]("commandQueue")
+      val exitCode = unbuilder.readField[Option[Long]]("exitCode")
      unbuilder.endObject()
-      sbt.protocol.ExecStatusEvent(status, channelName, execId, commandQueue)
+      sbt.protocol.ExecStatusEvent(status, channelName, execId, commandQueue, exitCode)
      case None =>
      deserializationError("Expected JsObject but found None")
    }
@ -27,6 +28,7 @@ implicit lazy val ExecStatusEventFormat: JsonFormat[sbt.protocol.ExecStatusEvent
    builder.addField("channelName", obj.channelName)
    builder.addField("execId", obj.execId)
    builder.addField("commandQueue", obj.commandQueue)
+    builder.addField("exitCode", obj.exitCode)
    builder.endObject()
  }
 }
--- a/protocol/src/main/contraband/server.contra
+++ b/protocol/src/main/contraband/server.contra
@ -43,6 +43,7 @@ type ExecStatusEvent implements EventMessage {
  channelName: String
  execId: String
  commandQueue: [String]
+  exitCode: Long @since("1.1.2")
 }

 interface SettingQueryResponse implements EventMessage {}
--- a/protocol/src/main/scala/sbt/internal/langserver/ErrorCodes.scala
+++ b/protocol/src/main/scala/sbt/internal/langserver/ErrorCodes.scala
@ -9,18 +9,40 @@ package sbt
 package internal
 package langserver

+/** Holds the error codes for the LSP implementation here. */
 object ErrorCodes {
-  // Defined by JSON RPC
-  val ParseError = -32700L
-  val InvalidRequest = -32600L
-  val MethodNotFound = -32601L
-  val InvalidParams = -32602L
-  val InternalError = -32603L
-  val serverErrorStart = -32099L
-  val serverErrorEnd = -32000L
-  val ServerNotInitialized = -32002L
-  val UnknownErrorCode = -32001L
+  // this is essentially a lookup table encoded in Scala,
+  // so heavy usage of vertical alignment is beneficial
+  // format: off

-  // Defined by the protocol.
-  val RequestCancelled = -32800L
+  // Defined by the JSON-RPC 2.0 Specification
+  // http://www.jsonrpc.org/specification#error_object
+  //
+  // The error codes from and including -32768 to -32000 are reserved for pre-defined errors.
+  // Any code within this range, but not defined explicitly below is reserved for future use.
+  //
+  // The error codes are nearly the same as those suggested for XML-RPC at the following url:
+  // http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
+  //
+  val ParseError     = -32700L       // Invalid JSON was received by the server.
+                                     // An error occurred on the server while parsing the JSON text.
+  val InvalidRequest = -32600L       // The JSON sent is not a valid Request object.
+  val MethodNotFound = -32601L       // The method does not exist / is not available.
+  val InvalidParams  = -32602L       // Invalid method parameter(s).
+  val InternalError  = -32603L       // Internal JSON-RPC error.
+
+
+  // The range -32000 to -32099 are reserved for implementation-defined server-errors.
+  val serverErrorStart = -32099L     // from LSP's spec code snippet
+  val serverErrorEnd   = -32000L     // from LSP's spec code snippet
+
+  val UnknownServerError   = -32001L // Defined by LSP
+  val ServerNotInitialized = -32002L // Defined by LSP
+
+
+  // The remainder of the space is available for application defined errors.
+  val RequestCancelled = -32800L     // Defined by LSP
+  val UnknownError     = -33000L     // A generic error, unknown if the user or server is at fault.
+
+  // format: on
 }
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcRequestMessageFormats.scala
@ -24,7 +24,10 @@ trait JsonRpcRequestMessageFormats {
            val id = try {
              unbuilder.readField[String]("id")
            } catch {
-              case _: DeserializationException => unbuilder.readField[Long]("id").toString
+              case _: DeserializationException => {
+                val prefix = "\u2668" // Append prefix to show the original type was Number
+                prefix + unbuilder.readField[Long]("id").toString
+              }
            }
            val method = unbuilder.readField[String]("method")
            val params = unbuilder.lookupField("params") map {
--- a/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
+++ b/protocol/src/main/scala/sbt/internal/protocol/codec/JsonRpcResponseMessageFormats.scala
@ -7,8 +7,14 @@

 package sbt.internal.protocol.codec

-import sjsonnew.{ Builder, DeserializationException, JsonFormat, Unbuilder, deserializationError }
-import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+import _root_.sjsonnew.{
+  Builder,
+  DeserializationException,
+  JsonFormat,
+  Unbuilder,
+  deserializationError
+}
+import sjsonnew.shaded.scalajson.ast.unsafe._

 trait JsonRpcResponseMessageFormats {
  self: sbt.internal.util.codec.JValueFormats
@ -46,10 +52,35 @@ trait JsonRpcResponseMessageFormats {
      }
      override def write[J](obj: sbt.internal.protocol.JsonRpcResponseMessage,
                            builder: Builder[J]): Unit = {
+        // Parse given id to Long or String judging by prefix
+        def parseId(str: String): Either[Long, String] = {
+          if (str.startsWith("\u2668")) Left(str.substring(1).toLong)
+          else Right(str)
+        }
+        def parseResult(jValue: JValue): JValue = jValue match {
+          case JObject(jFields) =>
+            val replaced = jFields map {
+              case field @ JField("execId", JString(str)) =>
+                parseId(str) match {
+                  case Right(strId) => field.copy(value = JString(strId))
+                  case Left(longId) => field.copy(value = JNumber(longId))
+                }
+              case other =>
+                other
+            }
+            JObject(replaced)
+          case other =>
+            other
+        }
        builder.beginObject()
        builder.addField("jsonrpc", obj.jsonrpc)
-        builder.addField("id", obj.id)
-        builder.addField("result", obj.result)
+        obj.id foreach { id =>
+          parseId(id) match {
+            case Right(strId) => builder.addField("id", strId)
+            case Left(longId) => builder.addField("id", longId)
+          }
+        }
+        builder.addField("result", obj.result map parseResult)
        builder.addField("error", obj.error)
        builder.endObject()
      }
--- a/run/src/main/contraband-scala/sbt/ForkOptions.scala
+++ b/run/src/main/contraband-scala/sbt/ForkOptions.scala
@ -43,7 +43,7 @@ final class ForkOptions private (
  override def toString: String = {
    "ForkOptions(" + javaHome + ", " + outputStrategy + ", " + bootJars + ", " + workingDirectory + ", " + runJVMOptions + ", " + connectInput + ", " + envVars + ")"
  }
-  protected[this] def copy(javaHome: Option[java.io.File] = javaHome, outputStrategy: Option[sbt.OutputStrategy] = outputStrategy, bootJars: Vector[java.io.File] = bootJars, workingDirectory: Option[java.io.File] = workingDirectory, runJVMOptions: Vector[String] = runJVMOptions, connectInput: Boolean = connectInput, envVars: scala.collection.immutable.Map[String, String] = envVars): ForkOptions = {
+  private[this] def copy(javaHome: Option[java.io.File] = javaHome, outputStrategy: Option[sbt.OutputStrategy] = outputStrategy, bootJars: Vector[java.io.File] = bootJars, workingDirectory: Option[java.io.File] = workingDirectory, runJVMOptions: Vector[String] = runJVMOptions, connectInput: Boolean = connectInput, envVars: scala.collection.immutable.Map[String, String] = envVars): ForkOptions = {
    new ForkOptions(javaHome, outputStrategy, bootJars, workingDirectory, runJVMOptions, connectInput, envVars)
  }
  def withJavaHome(javaHome: Option[java.io.File]): ForkOptions = {
@ -79,7 +79,7 @@ final class ForkOptions private (
 }
 object ForkOptions {
  
-  def apply(): ForkOptions = new ForkOptions(None, None, Vector(), None, Vector(), false, Map())
+  def apply(): ForkOptions = new ForkOptions()
  def apply(javaHome: Option[java.io.File], outputStrategy: Option[sbt.OutputStrategy], bootJars: Vector[java.io.File], workingDirectory: Option[java.io.File], runJVMOptions: Vector[String], connectInput: Boolean, envVars: scala.collection.immutable.Map[String, String]): ForkOptions = new ForkOptions(javaHome, outputStrategy, bootJars, workingDirectory, runJVMOptions, connectInput, envVars)
  def apply(javaHome: java.io.File, outputStrategy: sbt.OutputStrategy, bootJars: Vector[java.io.File], workingDirectory: java.io.File, runJVMOptions: Vector[String], connectInput: Boolean, envVars: scala.collection.immutable.Map[String, String]): ForkOptions = new ForkOptions(Option(javaHome), Option(outputStrategy), bootJars, Option(workingDirectory), runJVMOptions, connectInput, envVars)
 }
--- a/run/src/main/scala/sbt/OutputStrategy.scala
+++ b/run/src/main/scala/sbt/OutputStrategy.scala
@ -37,7 +37,7 @@ object OutputStrategy {
    override def toString: String = {
      "BufferedOutput(" + logger + ")"
    }
-    protected[this] def copy(logger: Logger = logger): BufferedOutput = {
+    private[this] def copy(logger: Logger = logger): BufferedOutput = {
      new BufferedOutput(logger)
    }
    def withLogger(logger: Logger): BufferedOutput = {
@ -63,7 +63,7 @@ object OutputStrategy {
    override def toString: String = {
      "LoggedOutput(" + logger + ")"
    }
-    protected[this] def copy(logger: Logger = logger): LoggedOutput = {
+    private[this] def copy(logger: Logger = logger): LoggedOutput = {
      new LoggedOutput(logger)
    }
    def withLogger(logger: Logger): LoggedOutput = {
@ -91,7 +91,7 @@ object OutputStrategy {
    override def toString: String = {
      "CustomOutput(" + output + ")"
    }
-    protected[this] def copy(output: OutputStream = output): CustomOutput = {
+    private[this] def copy(output: OutputStream = output): CustomOutput = {
      new CustomOutput(output)
    }
    def withOutput(output: OutputStream): CustomOutput = {
--- a/sbt/src/sbt-test/tests/fork-async/build.sbt
+++ b/sbt/src/sbt-test/tests/fork-async/build.sbt
@ -0,0 +1,8 @@
+testFrameworks += new TestFramework("utest.runner.Framework")
+
+lazy val root = (project in file(".")).
+  settings(
+    scalaVersion := "2.12.4",
+    libraryDependencies += "com.lihaoyi" %% "utest" % "0.6.4" % Test,
+    fork in Test := true
+  )
--- a/sbt/src/sbt-test/tests/fork-async/src/test/scala/ForkAsyncTest.scala
+++ b/sbt/src/sbt-test/tests/fork-async/src/test/scala/ForkAsyncTest.scala
@ -0,0 +1,21 @@
+import utest._
+
+import utest._
+import utest.framework._
+
+import scala.concurrent.{ ExecutionContext, Promise }
+import scala.util.Success
+
+object ForkAsyncTest extends TestSuite {
+  val g = ExecutionContext.global
+  val n = 10
+  val (testNames, promises) = (1 to n).map(i => Tree(s"$i") -> Promise[Unit]).unzip
+  val testTrees = promises.zipWithIndex.map { case (p, i) =>
+    new TestCallTree(Left {
+      if (i == (n - 1)) promises.foreach(p => g.execute(() => p.tryComplete(Success(()))))
+      p.future
+    })
+  }
+  val tests =
+    Tests(nameTree = Tree("async", testNames: _*), callTree = new TestCallTree(Right(testTrees)))
+}
--- a/sbt/src/sbt-test/tests/fork-async/test
+++ b/sbt/src/sbt-test/tests/fork-async/test
@ -0,0 +1 @@
+> test
--- a/sbt/src/test/scala/sbt/ServerSpec.scala
+++ b/sbt/src/test/scala/sbt/ServerSpec.scala
@ -9,6 +9,7 @@ package sbt

 import org.scalatest._
 import scala.concurrent._
+import scala.annotation.tailrec
 import java.io.{ InputStream, OutputStream }
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.{ ThreadFactory, ThreadPoolExecutor }
@ -23,19 +24,22 @@ class ServerSpec extends AsyncFlatSpec with Matchers {
        """{ "jsonrpc": "2.0", "id": 3, "method": "sbt/setting", "params": { "setting": "handshake/name" } }""",
        out)
      Thread.sleep(100)
-
-      println(readFrame(in))
-      println(readFrame(in))
-      println(readFrame(in))
-      println(readFrame(in))
-      // println(readFrame(in))
-
-      writeLine("""{ "jsonrpc": "2.0", "id": 10, "method": "lunar/helo", "params": {} }""", out)
-      Thread.sleep(100)
-
-      assert(1 == 1)
+      assert(waitFor(in, 10) { s =>
+        s contains """"id":3"""
+      })
    }
  }
+
+  @tailrec
+  private[this] def waitFor(in: InputStream, num: Int)(f: String => Boolean): Boolean = {
+    if (num < 0) false
+    else
+      readFrame(in) match {
+        case Some(x) if f(x) => true
+        case _ =>
+          waitFor(in, num - 1)(f)
+      }
+  }
 }

 object ServerSpec {
--- a/testing/agent/src/main/java/sbt/ForkMain.java
+++ b/testing/agent/src/main/java/sbt/ForkMain.java
@ -17,6 +17,7 @@ import java.net.Socket;
 import java.net.InetAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.*;

@ -294,7 +295,7 @@ final public class ForkMain {
 					Task[] nestedTasks;
 					final TaskDef taskDef = task.taskDef();
 					try {
-						final List<ForkEvent> eventList = new ArrayList<ForkEvent>();
+						final Collection<ForkEvent> eventList = new ConcurrentLinkedDeque<ForkEvent>();
 						final EventHandler handler = new EventHandler() { public void handle(final Event e){ eventList.add(new ForkEvent(e)); } };
 						logDebug(os, "  Running " + taskDef);
 						nestedTasks = task.execute(handler, loggers);
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupErrorEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupErrorEvent.scala
@ -21,7 +21,7 @@ final class EndTestGroupErrorEvent private (
  override def toString: String = {
    "EndTestGroupErrorEvent(" + name + ", " + error + ")"
  }
-  protected[this] def copy(name: String = name, error: String = error): EndTestGroupErrorEvent = {
+  private[this] def copy(name: String = name, error: String = error): EndTestGroupErrorEvent = {
    new EndTestGroupErrorEvent(name, error)
  }
  def withName(name: String): EndTestGroupErrorEvent = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/EndTestGroupEvent.scala
@ -21,7 +21,7 @@ final class EndTestGroupEvent private (
  override def toString: String = {
    "EndTestGroupEvent(" + name + ", " + result + ")"
  }
-  protected[this] def copy(name: String = name, result: sbt.protocol.testing.TestResult = result): EndTestGroupEvent = {
+  private[this] def copy(name: String = name, result: sbt.protocol.testing.TestResult = result): EndTestGroupEvent = {
    new EndTestGroupEvent(name, result)
  }
  def withName(name: String): EndTestGroupEvent = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/StartTestGroupEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/StartTestGroupEvent.scala
@ -20,7 +20,7 @@ final class StartTestGroupEvent private (
  override def toString: String = {
    "StartTestGroupEvent(" + name + ")"
  }
-  protected[this] def copy(name: String = name): StartTestGroupEvent = {
+  private[this] def copy(name: String = name): StartTestGroupEvent = {
    new StartTestGroupEvent(name)
  }
  def withName(name: String): StartTestGroupEvent = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/TestCompleteEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestCompleteEvent.scala
@ -20,7 +20,7 @@ final class TestCompleteEvent private (
  override def toString: String = {
    "TestCompleteEvent(" + result + ")"
  }
-  protected[this] def copy(result: sbt.protocol.testing.TestResult = result): TestCompleteEvent = {
+  private[this] def copy(result: sbt.protocol.testing.TestResult = result): TestCompleteEvent = {
    new TestCompleteEvent(result)
  }
  def withResult(result: sbt.protocol.testing.TestResult): TestCompleteEvent = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/TestInitEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestInitEvent.scala
@ -19,7 +19,7 @@ override def hashCode: Int = {
 override def toString: String = {
  "TestInitEvent()"
 }
-protected[this] def copy(): TestInitEvent = {
+private[this] def copy(): TestInitEvent = {
  new TestInitEvent()
 }

--- a/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemDetail.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemDetail.scala
@ -31,7 +31,7 @@ final class TestItemDetail private (
  override def toString: String = {
    "TestItemDetail(" + fullyQualifiedName + ", " + status + ", " + duration + ")"
  }
-  protected[this] def copy(fullyQualifiedName: String = fullyQualifiedName, status: sbt.testing.Status = status, duration: Option[Long] = duration): TestItemDetail = {
+  private[this] def copy(fullyQualifiedName: String = fullyQualifiedName, status: sbt.testing.Status = status, duration: Option[Long] = duration): TestItemDetail = {
    new TestItemDetail(fullyQualifiedName, status, duration)
  }
  def withFullyQualifiedName(fullyQualifiedName: String): TestItemDetail = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestItemEvent.scala
@ -21,7 +21,7 @@ final class TestItemEvent private (
  override def toString: String = {
    "TestItemEvent(" + result + ", " + detail + ")"
  }
-  protected[this] def copy(result: Option[sbt.protocol.testing.TestResult] = result, detail: Vector[sbt.protocol.testing.TestItemDetail] = detail): TestItemEvent = {
+  private[this] def copy(result: Option[sbt.protocol.testing.TestResult] = result, detail: Vector[sbt.protocol.testing.TestItemDetail] = detail): TestItemEvent = {
    new TestItemEvent(result, detail)
  }
  def withResult(result: Option[sbt.protocol.testing.TestResult]): TestItemEvent = {
--- a/testing/src/main/contraband-scala/sbt/protocol/testing/TestStringEvent.scala
+++ b/testing/src/main/contraband-scala/sbt/protocol/testing/TestStringEvent.scala
@ -19,7 +19,7 @@ final class TestStringEvent private (
  override def toString: String = {
    value
  }
-  protected[this] def copy(value: String = value): TestStringEvent = {
+  private[this] def copy(value: String = value): TestStringEvent = {
    new TestStringEvent(value)
  }
  def withValue(value: String): TestStringEvent = {