Merge pull request #4047 from eed3si9n/wip/merge-1.1.x

merge 1.1.x

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
 ```

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"),
+      exclude[IncompatibleMethTypeProblem]("sbt.TestStatus.write"),
-      ProblemFilters.exclude[IncompatibleResultTypeProblem]("sbt.TestStatus.read"),
+      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

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 = {

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: Option[sbt.CommandSource]): Exec = new Exec(commandLine, source)
-  def apply(commandLine: String, source: sbt.CommandSource): Exec = new Exec(commandLine, None, Option(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))
 }

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,
+    new ScalaInstance(
-                      makeClassLoader(state.value)(allJars.toList),
+      scalaVersion.value,
-                      libraryJar,
+      makeClassLoader(state.value)(allJars.toList),
-                      compilerJar,
+      makeClassLoader(state.value)(List(libraryJar)),
-                      allJars.toArray,
+      libraryJar,
-                      None)
+      compilerJar,
+      allJars.toArray,
+      None
+    )
   }
   def scalaInstanceFromHome(dir: File): Initialize[Task[ScalaInstance]] = Def.task {
     ScalaInstance(dir)(makeClassLoader(state.value))

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
+
 }

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 {

main/src/main/scala/sbt/internal/LogManager.scala

@@ -229,8 +229,13 @@ object LogManager {
   //     s
   //   }
 
-  def setGlobalLogLevel(s: State, level: Level.Value): State =
+  def setGlobalLogLevel(s: State, level: Level.Value): State = {
-    s.put(BasicKeys.explicitGlobalLogLevels, true).put(Keys.logLevel.key, level)
+    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

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))))
             ()
         }
       )

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 {

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 utilVersion = "1.1.3"
-  private val lmVersion = "1.1.3"
+  private val lmVersion = "1.1.4"
-  private val zincVersion = "1.1.1"
+  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 launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.0.3"
-  val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.2"
+  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"
 

project/build.properties

@@ -1 +1 @@
-sbt.version=1.1.1
+sbt.version=1.1.2

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")

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()
 }
 

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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))
 }

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 = {
+  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)
+    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))
 }

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 = {

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 = {

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 = {

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 = {

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 = {

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 = {

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()
   }
 }

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 {}

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
+  // this is essentially a lookup table encoded in Scala,
-  val ParseError = -32700L
+  // so heavy usage of vertical alignment is beneficial
-  val InvalidRequest = -32600L
+  // format: off
-  val MethodNotFound = -32601L
-  val InvalidParams = -32602L
-  val InternalError = -32603L
-  val serverErrorStart = -32099L
-  val serverErrorEnd = -32000L
-  val ServerNotInitialized = -32002L
-  val UnknownErrorCode = -32001L
 
-  // Defined by the protocol.
+  // Defined by the JSON-RPC 2.0 Specification
-  val RequestCancelled = -32800L
+  // 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
 }

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 {

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 _root_.sjsonnew.{
-import sjsonnew.shaded.scalajson.ast.unsafe.JValue
+  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)
+        obj.id foreach { id =>
-        builder.addField("result", obj.result)
+          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()
       }

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)
 }

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 = {

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
+  )

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)))
+}

sbt/src/sbt-test/tests/fork-async/test

@@ -0,0 +1 @@
+> test

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)
-
+      assert(waitFor(in, 10) { s =>
-      println(readFrame(in))
+        s contains """"id":3"""
-      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)
     }
   }
+
+  @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 {

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);

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 = {

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 = {

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 = {

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 = {

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()
 }
 

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 = {

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 = {

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 = {