Fancy bots

app/Env.scala

@@ -26,6 +26,7 @@ final class Env(
   given scheduler: Scheduler                  = system.scheduler
   given RateLimit                             = net.rateLimit
   given NetDomain                             = net.domain
+  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
@@ -98,6 +99,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

@@ -128,6 +128,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,99 @@
+package controllers
+
+import play.api.libs.json.*
+import play.api.mvc.*
+
+import lila.app.{ given, * }
+import lila.common.Json.given
+import lila.local.{ AssetType, BotJson }
+
+final class Local(env: Env) extends LilaController(env):
+
+  extension (r: Result)
+    def withServiceWorker(using RequestHeader) =
+      r.enforceCrossSiteIsolation.withHeaders("Service-Worker-Allowed" -> "/")
+
+  def index = Secure(_.Beta) { _ ?=> _ ?=>
+    for
+      bots <- env.local.repo.getLatestBots()
+      res <- negotiate(
+        html =
+          for page <- renderPage(indexPage(bots))
+          yield Ok(page).withServiceWorker,
+        json = JsonOk(Json.obj("bots" -> bots))
+      )
+    yield res
+  }
+
+  def assetKeys = Anon: // for service worker
+    JsonOk(env.local.api.getJson)
+
+  def devIndex = Secure(_.BotEditor): _ ?=>
+    for
+      bots   <- env.local.repo.getLatestBots()
+      assets <- env.local.api.devGetAssets
+      page   <- renderPage(indexPage(bots, assets.some))
+    yield Ok(page).withServiceWorker
+
+  def devAssets = Secure(_.BotEditor): ctx ?=>
+    env.local.api.devGetAssets.map(JsonOk)
+
+  def devBotHistory(botId: Option[UserStr]) = Secure(_.BotEditor): _ ?=>
+    env.local.repo
+      .getVersions(botId.map(_.id))
+      .map: history =>
+        JsonOk(Json.obj("bots" -> history))
+
+  def devPostBot = SecureBody(parse.json)(_.BotEditor) { ctx ?=> me ?=>
+    ctx.body.body
+      .validate[JsObject]
+      .fold(
+        err => BadRequest(jsonError(err.toString)),
+        bot => env.local.repo.putBot(BotJson(bot), me.userId).map(JsonOk)
+      )
+  }
+
+  def devNameAsset(key: String, name: String) = Secure(_.BotEditor): _ ?=>
+    env.local.repo
+      .nameAsset(none, key, name, none)
+      .flatMap(_ => env.local.api.devGetAssets.map(JsonOk))
+
+  def devDeleteAsset(key: String) = Secure(_.BotEditor): _ ?=>
+    env.local.repo
+      .deleteAsset(key)
+      .flatMap(_ => env.local.api.devGetAssets.map(JsonOk))
+
+  def devPostAsset(tpe: String, key: String) = SecureBody(parse.multipartFormData)(_.BotEditor) { ctx ?=>
+    AssetType
+      .read(tpe)
+      .so: (tpe: AssetType) =>
+        def formValue(field: String) = ctx.body.body.dataParts.get(field).flatMap(_.headOption)
+        val author: Option[UserId]   = formValue("author").flatMap(UserStr.read).map(_.id)
+        val name                     = formValue("name").getOrElse(key)
+        ctx.body.body
+          .file("file")
+          .map: file =>
+            env.local.api
+              .storeAsset(tpe, key, file)
+              .flatMap:
+                case Left(error) => InternalServerError(jsonError(error)).as(JSON)
+                case Right(assets) =>
+                  for _ <- env.local.repo.nameAsset(tpe.some, key, name, author)
+                  yield JsonOk(Json.obj("key" -> key, "name" -> name))
+          .getOrElse(BadRequest(jsonError("missing file")).as(JSON))
+  }
+
+  private def indexPage(bots: List[BotJson], devAssets: Option[JsObject] = none)(using Context) =
+    views.local.index(
+      Json
+        .obj("pref" -> pref, "bots" -> bots)
+        .add("assets", devAssets)
+        .add("canPost", isGrantedOpt(_.BotEditor)),
+      if devAssets.isDefined then "local.dev" else "local"
+    )
+
+  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)

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/game/widgets.scala

@@ -10,6 +10,7 @@ object widgets:
 
   private val separator = " • "
 
+  // mirrored html generation in file://../../../ui/user/src/user.ts
   def apply(
       games: Seq[Game],
       notes: Map[GameId, String] = Map(),

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/schlawg-dev

@@ -3,7 +3,7 @@
 journalctl --user -fu lila -o cat | grep -E -v fishnet &
 JOURNALCTL_PID=$!
 
-# l=/ui-build
+# l=https://schlawg.org/console
 "$(dirname "${BASH_SOURCE[0]:-$0}")/../ui/build" -${1:-'wd'} &
 UI_BUILD_PID=$!
 

build.sbt

@@ -75,7 +75,7 @@ lazy val modules = Seq(
   // and then the smaller ones
   pool, lobby, relation, tv, coordinate, feed, history, recap,
   shutup, appeal, irc, explorer, learn, event, coach,
-  practice, evalCache, irwin, bot, racer, cms, i18n,
+  practice, evalCache, irwin, bot, racer, cms, i18n, local,
   socket, bookmark, studySearch, gameSearch, forumSearch, teamSearch,
 )
 
@@ -148,6 +148,11 @@ lazy val racer = module("racer",
   Seq()
 )
 
+lazy val local = module("local",
+  Seq(db, ui),
+  Seq()
+)
+
 lazy val video = module("video",
   Seq(memo, ui),
   macwire.bundle

conf/base.conf

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

conf/routes

@@ -350,6 +350,17 @@ 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   /bots                            controllers.Local.index
+GET   /bots/assets                    controllers.Local.assetKeys
+GET   /bots/dev                       controllers.Local.devIndex
+GET   /bots/dev/history               controllers.Local.devBotHistory(id: Option[UserStr])
+POST  /bots/dev/bot                   controllers.Local.devPostBot
+GET   /bots/dev/assets                controllers.Local.devAssets
+POST  /bots/dev/asset/$tpe<sound|image|book>/$key<\w{12}(\.\w{2,4})?> controllers.Local.devPostAsset(tpe: String, key: String)
+POST  /bots/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/common/src/main/Json.scala

@@ -32,3 +32,5 @@ object Json:
       .add("title", u.title)
       .add("flair", u.flair)
       .add("patron", u.isPatron)
+
+  trait OpaqueJson[A](using A =:= JsObject) extends TotalWrapper[A, JsObject]

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/db/src/main/JSON.scala

@@ -16,9 +16,8 @@ object JSON:
     case JsArray(arr)     => BSONArray(arr.map(bval))
     case _                => BSONNull
 
-  def jval(bson: BSONDocument): JsValue = Json.obj(
-    bson.elements.map(el => el.name -> jval(el.value))*
-  )
+  def jval(bson: BSONDocument): JsObject = JsObject:
+    bson.elements.map(el => el.name -> jval(el.value))
 
   def jval(bson: BSONValue): JsValue = bson match
     case BSONString(value)  => JsString(value)

modules/forum/src/main/ForumForm.scala

@@ -46,13 +46,12 @@ final private[forum] class ForumForm(
     single("categ" -> nonEmptyText.into[ForumCategId])
 
   private def userTextMapping(inOwnTeam: Boolean, previousText: Option[String] = None)(using me: Me) =
-    cleanText(minLength = 3, 20_000)
+    cleanText(minLength = 3, 10_000_000) // bot move dumps
       .verifying(
         "You have reached the daily maximum for links in forum posts.",
         t => inOwnTeam || promotion.test(me, t, previousText)
       )
-
-  val diagnostic = Form(single("text" -> nonEmptyText(maxLength = 100_000)))
+  val diagnostic = Form(single("text" -> nonEmptyText(maxLength = 10_000_000))) // bot move dumps
 
 object ForumForm:
 

modules/local/src/main/Env.scala

@@ -0,0 +1,25 @@
+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):
+
+  private val config: LocalConfig = appConfig.get[LocalConfig]("local")(AutoConfig.loader)
+
+  val repo = LocalRepo(db(CollName("local_bot")), db(CollName("local_asset")))
+
+  val api: LocalApi = wire[LocalApi]

modules/local/src/main/LocalApi.scala

@@ -0,0 +1,67 @@
+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
+):
+
+  type AlmostFileName = String
+  type LocalAssets    = Map[AssetType, List[AlmostFileName]]
+
+  @volatile private var cachedAssets: Option[(LocalAssets, JsonStr)] = None
+
+  def storeAsset(
+      tpe: AssetType,
+      fileName: String,
+      file: MultipartFormData.FilePart[Files.TemporaryFile]
+  ): Fu[Either[String, (LocalAssets, JsonStr)]] =
+    FileIO
+      .fromPath(file.ref.path)
+      .runWith(FileIO.toPath(getFile(s"${config.assetPath}/${tpe}/$fileName").toPath))
+      .map(_ => Right(updateAssets))
+      .recover:
+        case e: Exception => Left(s"Exception: ${e.getMessage}")
+
+  def getBoth: (LocalAssets, JsonStr) = cachedAssets.getOrElse(updateAssets)
+  def getAssets: LocalAssets          = getBoth._1
+  def getJson: JsonStr                = getBoth._2
+
+  def devGetAssets: Fu[JsObject] =
+    repo.getAssets.map: m =>
+      Json.toJsObject:
+        getAssets.map: (categ, keys) =>
+          categ -> (for
+            key  <- keys
+            name <- m.get(key)
+          yield Json.obj("key" -> key, "name" -> name))
+
+  private def listFiles(tpe: AssetType, ext: String): List[AlmostFileName] =
+    val path = getFile(s"${config.assetPath}/${tpe}")
+    if !path.exists() then
+      NioFiles.createDirectories(path.toPath)
+      Nil
+    else
+      path
+        .listFiles(_.getName.endsWith(s".${ext}"))
+        .toList
+        .map(_.getName)
+
+  def updateAssets: (LocalAssets, JsonStr) =
+    val data: LocalAssets = Map(
+      "image" -> listFiles("image", "webp"),
+      "net"   -> listFiles("net", "pb"),
+      "sound" -> listFiles("sound", "mp3"),
+      "book"  -> listFiles("book", "png").map(_.dropRight(4))
+    )
+    val newAssets = (data, JsonStr(Json.stringify(Json.toJson(data))))
+    cachedAssets = newAssets.some
+    newAssets