schlawg/local-play

app/Env.scala

@@ -25,6 +25,7 @@ final class Env(
   given translator: lila.core.i18n.Translator = lila.i18n.Translator
   given scheduler: Scheduler                  = system.scheduler
   given lila.core.config.RateLimit            = net.rateLimit
+  given getFile: (String => java.io.File)     = environment.getFile
 
   // wire all the lila modules in the right order
   val i18n: lila.i18n.Env.type          = lila.i18n.Env
@@ -94,6 +95,7 @@ final class Env(
   val bot: lila.bot.Env                 = wire[lila.bot.Env]
   val storm: lila.storm.Env             = wire[lila.storm.Env]
   val racer: lila.racer.Env             = wire[lila.racer.Env]
+  val local: lila.local.Env             = wire[lila.local.Env]
   val opening: lila.opening.Env         = wire[lila.opening.Env]
   val tutor: lila.tutor.Env             = wire[lila.tutor.Env]
   val recap: lila.recap.Env             = wire[lila.recap.Env]

app/LilaComponents.scala

@@ -126,6 +126,7 @@ final class LilaComponents(
   lazy val irwin: Irwin                   = wire[Irwin]
   lazy val learn: Learn                   = wire[Learn]
   lazy val lobby: Lobby                   = wire[Lobby]
+  lazy val localPlay: Local               = wire[Local]
   lazy val main: Main                     = wire[Main]
   lazy val msg: Msg                       = wire[Msg]
   lazy val mod: Mod                       = wire[Mod]

app/controllers/Local.scala

@@ -0,0 +1,138 @@
+package controllers
+
+import play.api.libs.json.*
+import play.api.i18n.Lang
+import play.api.mvc.*
+import play.api.data.*
+import play.api.data.Forms.*
+import views.*
+
+import lila.app.{ given, * }
+import lila.common.Json.given
+import lila.user.User
+import lila.rating.{ Perf, PerfType }
+import lila.security.Permission
+import lila.local.{ GameSetup, AssetType }
+
+final class Local(env: Env) extends LilaController(env):
+  def index(
+      white: Option[String],
+      black: Option[String],
+      fen: Option[String],
+      time: Option[String],
+      go: Option[String]
+  ) = Open:
+    val initial   = time.map(_.toFloat)
+    val increment = time.flatMap(_.split('+').drop(1).headOption.map(_.toFloat))
+    val setup =
+      if white.isDefined || black.isDefined || fen.isDefined || time.isDefined then
+        GameSetup(white, black, fen, initial, increment, optTrue(go)).some
+      else none
+    for
+      bots <- env.local.repo.getLatestBots()
+      page <- renderPage(indexPage(setup, bots, none))
+    yield Ok(page).enforceCrossSiteIsolation.withHeaders("Service-Worker-Allowed" -> "/")
+
+  def bots = Open:
+    env.local.repo
+      .getLatestBots()
+      .map: bots =>
+        JsonOk(Json.obj("bots" -> bots))
+
+  def assetKeys = Open: // for service worker
+    JsonOk(env.local.api.assetKeys)
+
+  def devIndex = Auth: _ ?=>
+    for
+      bots   <- env.local.repo.getLatestBots()
+      assets <- getDevAssets
+      page   <- renderPage(indexPage(none, bots, assets.some))
+    yield Ok(page).enforceCrossSiteIsolation.withHeaders("Service-Worker-Allowed" -> "/")
+
+  def devAssets = Auth: ctx ?=>
+    getDevAssets.map(JsonOk)
+
+  def devBotHistory(botId: Option[String]) = Auth: _ ?=>
+    env.local.repo
+      .getVersions(botId.map(UserId.apply))
+      .map: history =>
+        JsonOk(Json.obj("bots" -> history))
+
+  def devPostBot = SecureBody(parse.json)(_.BotEditor) { ctx ?=> me ?=>
+    ctx.body.body
+      .validate[JsObject]
+      .fold(
+        err => BadRequest(Json.obj("error" -> err.toString)),
+        bot =>
+          env.local.repo
+            .putBot(bot, me.userId)
+            .map: updatedBot =>
+              JsonOk(updatedBot)
+      )
+  }
+
+  def devNameAsset(key: String, name: String) = Secure(_.BotEditor): _ ?=>
+    env.local.repo
+      .nameAsset(none, key, name, none)
+      .flatMap(_ => getDevAssets.map(JsonOk))
+
+  def devDeleteAsset(key: String) = Secure(_.BotEditor): _ ?=>
+    env.local.repo
+      .deleteAsset(key)
+      .flatMap(_ => getDevAssets.map(JsonOk))
+
+  def devPostAsset(notAString: String, key: String) = SecureBody(parse.multipartFormData)(_.BotEditor) {
+    ctx ?=>
+      val tpe: AssetType         = notAString.asInstanceOf[AssetType]
+      val author: Option[String] = ctx.body.body.dataParts.get("author").flatMap(_.headOption)
+      val name                   = ctx.body.body.dataParts.get("name").flatMap(_.headOption).getOrElse(key)
+      ctx.body.body
+        .file("file")
+        .map: file =>
+          env.local.api
+            .storeAsset(tpe, key, file)
+            .flatMap:
+              case Left(error) => InternalServerError(Json.obj("error" -> error.toString)).as(JSON)
+              case Right(assets) =>
+                env.local.repo
+                  .nameAsset(tpe.some, key, name, author)
+                  .flatMap(_ => (JsonOk(Json.obj("key" -> key, "name" -> name))))
+        .getOrElse(fuccess(BadRequest(Json.obj("error" -> "missing file")).as(JSON)))
+  }
+
+  private def indexPage(setup: Option[GameSetup], bots: JsArray, devAssets: Option[JsObject] = none)(using
+      ctx: Context
+  ) =
+    given setupFormat: Format[GameSetup] = Json.format[GameSetup]
+    views.local.index(
+      Json
+        .obj("pref" -> pref, "bots" -> bots)
+        .add("setup", setup)
+        .add("assets", devAssets)
+        .add("userId", ctx.me.map(_.userId))
+        .add("username", ctx.me.map(_.username))
+        .add("canPost", isGrantedOpt(_.BotEditor)),
+      if devAssets.isDefined then "local.dev" else "local"
+    )
+
+  private def getDevAssets =
+    env.local.repo.getAssets.map: m =>
+      JsObject:
+        env.local.api.assetKeys
+          .as[JsObject]
+          .fields
+          .collect:
+            case (category, JsArray(keys)) =>
+              category -> JsArray:
+                keys.collect:
+                  case JsString(key) if m.contains(key) =>
+                    Json.obj("key" -> key, "name" -> m(key))
+
+  private def pref(using ctx: Context) =
+    lila.pref.JsonView
+      .write(ctx.pref, false)
+      .add("animationDuration", ctx.pref.animationMillis.some)
+      .add("enablePremove", ctx.pref.premove.some)
+
+  private def optTrue(s: Option[String]) =
+    s.exists(v => v == "" || v == "1" || v == "true")

app/controllers/Push.scala

@@ -15,7 +15,7 @@ final class Push(env: Env) extends LilaController(env):
 
   def webSubscribe = AuthBody(parse.json) { ctx ?=> me ?=>
     val currentSessionId = ~env.security.api.reqSessionId(ctx.req)
-    ctx.body.body
+    ctx.body.body.pp
       .validate[WebSubscription]
       .fold(
         err => BadRequest(err.toString),

app/controllers/Round.scala

@@ -71,7 +71,7 @@ final class Round(
               jsChat <- chat.flatMap(_.game).map(_.chat).soFu(lila.chat.JsonView.asyncLines)
             yield Ok(data.add("chat", jsChat)).noCache
       )
-    yield res
+    yield res.enforceCrossSiteIsolation
 
   def player(fullId: GameFullId) = Open:
     env.round.proxyRepo

app/views/ui.scala

@@ -87,6 +87,8 @@ val challenge = lila.challenge.ui.ChallengeUi(helpers)
 
 val dev = lila.web.ui.DevUi(helpers)(mod.ui.menu)
 
+val local = lila.local.ui.LocalUi(helpers)
+
 def mobile(p: lila.cms.CmsPage.Render)(using Context) =
   lila.web.ui.mobile(helpers)(cms.render(p))
 

bin/deploy

@@ -116,7 +116,6 @@ PROFILES = {
     "manta-assets": asset_profile("[email protected]", deploy_dir="/home/lichess"),
 }
 
-
 class DeployError(Exception):
     pass
 
@@ -313,7 +312,7 @@ def deploy_script(profile, session, run, url):
         ]
     else:
         commands += [
-            f'echo "{artifact_unzipped}/d/{symlink} -> {deploy_dir}/{symlink}";ln -f --no-target-directory -s {artifact_unzipped}/d/{symlink} {deploy_dir}/{symlink}'
+            f'echo "{artifact_unzipped}/d/{symlink} -> {deploy_dir}/{symlink}"; ln -f --no-target-directory -s {artifact_unzipped}/d/{symlink} {deploy_dir}/{symlink}'
             for symlink in profile["symlinks"]
         ] + [f"chmod -f +x {deploy_dir}/bin/lila || true"]
 

build.sbt

@@ -77,7 +77,7 @@ lazy val modules = Seq(
   pool, lobby, relation, tv, coordinate, feed, history, recap,
   shutup, appeal, irc, explorer, learn, event, coach,
   practice, evalCache, irwin, bot, racer, cms, i18n,
-  socket, bookmark, studySearch, gameSearch, forumSearch, teamSearch,
+  socket, bookmark, studySearch, gameSearch, forumSearch, teamSearch, local
 )
 
 lazy val moduleRefs = modules map projectToRef
@@ -150,6 +150,11 @@ lazy val racer = module("racer",
   Seq()
 )
 
+lazy val local = module("local",
+  Seq(db, memo, ui, pref),
+  Seq()
+)
+
 lazy val video = module("video",
   Seq(memo, ui),
   macwire.bundle

conf/base.conf

@@ -378,6 +378,7 @@ insight {
 learn {
   collection.progress = learn_progress
 }
+local.asset_path = "public/lifat/bots"
 kaladin.enabled = false
 zulip {
   domain = ""

conf/routes

@@ -346,6 +346,18 @@ GET   /streamer/:username              controllers.Streamer.show(username: UserS
 GET   /streamer/:username/redirect     controllers.Streamer.redirect(username: UserStr)
 POST  /streamer/:username/check        controllers.Streamer.checkOnline(username: UserStr)
 
+# Private Play
+
+GET   /local                           controllers.Local.index(white: Option[String], black: Option[String], fen: Option[String], time: Option[String], go: Option[String])
+GET   /local/bots                      controllers.Local.bots
+GET   /local/assets                    controllers.Local.assetKeys
+GET   /local/dev                       controllers.Local.devIndex
+GET   /local/dev/history               controllers.Local.devBotHistory(id: Option[String])
+POST  /local/dev/bot                   controllers.Local.devPostBot
+GET   /local/dev/assets                controllers.Local.devAssets
+POST  /local/dev/asset/$tpe<sound|image|book>/$key<\w{12}(\.\w{2,4})?> controllers.Local.devPostAsset(tpe: String, key: String)
+POST  /local/dev/asset/mv/$key<\w{12}(\.\w{2,4})?>/:name  controllers.Local.devNameAsset(key: String, name: String)
+
 # Round
 GET   /$gameId<\w{8}>                            controllers.Round.watcher(gameId: GameId, color: Color = Color.white)
 GET   /$gameId<\w{8}>/$color<white|black>        controllers.Round.watcher(gameId: GameId, color: Color)

modules/core/src/main/perm.scala

@@ -103,6 +103,7 @@ enum Permission(val key: String, val alsoGrants: List[Permission], val name: Str
   case ApiHog            extends Permission("API_HOG", "API hog")
   case ApiChallengeAdmin extends Permission("API_CHALLENGE_ADMIN", "API Challenge admin")
   case LichessTeam       extends Permission("LICHESS_TEAM", List(Beta), "Lichess team")
+  case BotEditor         extends Permission("BOT_EDITOR", "Bot editor")
   case TimeoutMod
       extends Permission(
         "TIMEOUT_MOD",
@@ -188,6 +189,7 @@ enum Permission(val key: String, val alsoGrants: List[Permission], val name: Str
       extends Permission(
         "ADMIN",
         List(
+          BotEditor,
           LichessTeam,
           UserSearch,
           PrizeBan,
@@ -243,7 +245,7 @@ object Permission:
   val all: Set[Permission] = values.toSet
 
   val nonModPermissions: Set[Permission] =
-    Set(Beta, Coach, Teacher, Developer, Verified, ContentTeam, BroadcastTeam, ApiHog)
+    Set(Beta, Coach, Teacher, Developer, Verified, ContentTeam, BroadcastTeam, ApiHog, BotEditor)
 
   val modPermissions: Set[Permission] = all.diff(nonModPermissions)
 

modules/local/src/main/Env.scala

@@ -0,0 +1,28 @@
+package lila.local
+
+import com.softwaremill.macwire.*
+import play.api.Configuration
+
+import lila.common.autoconfig.{ *, given }
+import lila.core.config.*
+
+@Module
+final private class LocalConfig(
+    @ConfigName("asset_path") val assetPath: String
+)
+
+@Module
+final class Env(
+    appConfig: Configuration,
+    db: lila.db.Db,
+    getFile: (String => java.io.File)
+)(using
+    Executor,
+    akka.stream.Materializer
+)(using mode: play.api.Mode, scheduler: Scheduler):
+
+  private val config: LocalConfig = appConfig.get[LocalConfig]("local")(AutoConfig.loader)
+
+  val repo = LocalRepo(db(CollName("local_bots")), db(CollName("local_assets")))
+
+  val api: LocalApi = wire[LocalApi]

modules/local/src/main/LocalApi.scala

@@ -0,0 +1,56 @@
+package lila.local
+
+import java.nio.file.{ Files as NioFiles, Paths }
+import play.api.libs.json.*
+import play.api.libs.Files
+import play.api.mvc.*
+import akka.stream.scaladsl.{ FileIO, Source }
+import akka.util.ByteString
+
+// this stuff is for bot devs
+
+final private class LocalApi(config: LocalConfig, repo: LocalRepo, getFile: (String => java.io.File))(using
+    Executor,
+    akka.stream.Materializer
+):
+
+  @volatile private var cachedAssets: Option[JsObject] = None
+
+  def storeAsset(
+      tpe: "image" | "book" | "sound",
+      name: String,
+      file: MultipartFormData.FilePart[Files.TemporaryFile]
+  ): Fu[Either[String, JsObject]] =
+    FileIO
+      .fromPath(file.ref.path)
+      .runWith(FileIO.toPath(getFile(s"public/lifat/bots/${tpe}/$name").toPath))
+      .map: result =>
+        if result.wasSuccessful then Right(updateAssets)
+        else Left(s"Error uploading asset $tpe $name")
+      .recover:
+        case e: Exception => Left(s"Exception: ${e.getMessage}")
+
+  def assetKeys: JsObject = cachedAssets.getOrElse(updateAssets)
+
+  private def listFiles(tpe: String): List[String] =
+    val path = getFile(s"public/lifat/bots/${tpe}")
+    if !path.exists() then
+      NioFiles.createDirectories(path.toPath)
+      Nil
+    else
+      path
+        .listFiles()
+        .toList
+        .map(_.getName)
+
+  def updateAssets: JsObject =
+    val newAssets = Json.obj(
+      "image" -> listFiles("image"),
+      "net"   -> listFiles("net"),
+      "sound" -> listFiles("sound"),
+      "book" -> listFiles("book")
+        .filter(_.endsWith(".bin"))
+        .map(_.dropRight(4))
+    )
+    cachedAssets = newAssets.some
+    newAssets