:truck: Migrate lustre cli to fresh repo.

.github/workflows/test.yml

···
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "26.0.2"
+          gleam-version: "1.0.0"
+          rebar3-version: "3"
+          # elixir-version: "1.15.4"
+      - run: gleam deps download
+      - run: gleam test
+      - run: gleam format --check src test

.gitignore

···
+*.beam
+*.ez
+build
+erl_crash.dump

README.md

···
+# lustre_dev_tools
+
+[![Package Version](https://img.shields.io/hexpm/v/lustre_dev_tools)](https://hex.pm/packages/lustre_dev_tools)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/lustre_dev_tools/)
+
+```sh
+gleam add lustre_dev_tools
+```
+```gleam
+import lustre_dev_tools
+
+pub fn main() {
+  // TODO: An example of the project in use
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/lustre_dev_tools>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+gleam shell # Run an Erlang shell
+```

gleam.toml

···
+name = "lustre_dev_tools"
+version = "1.0.0"
+
+description = "Lustre's official CLI and development tooling."
+repository = { type = "github", user = "lustre-labs", repo = "dev-tools" }
+licences = ["MIT"]
+
+links = [
+  { title = "Sponsor", href = "https://github.com/sponsors/hayleigh-dot-dev" },
+]
+
+internal_modules = ["lusre_dev_tools", "lusre_dev_tools/*"]
+
+[dependencies]
+gleam_stdlib = "~> 0.34 or ~> 1.0"
+glint = "0.16.0"
+spinner = "~> 1.1"
+gleam_package_interface = "~> 1.0"
+tom = "~> 0.3"
+gleam_erlang = "~> 0.25"
+gleam_otp = "~> 0.10"
+fs = "~> 8.6"
+gleam_community_ansi = "~> 1.4"
+filepath = "~> 0.1"
+simplifile = "~> 1.5"
+gleam_json = "~> 1.0"
+argv = "~> 1.0"
+
+[dev-dependencies]
+gleeunit = "~> 1.0"

manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "argv", version = "1.0.1", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "A6E9009E50BBE863EB37D963E4315398D41A3D87D0075480FC244125808F964A" },
+  { name = "filepath", version = "0.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "FC1B1B29438A5BA6C990F8047A011430BEC0C5BA638BFAA62718C4EAEFE00435" },
+  { name = "fs", version = "8.6.1", build_tools = ["rebar3"], requirements = [], otp_app = "fs", source = "hex", outer_checksum = "61EA2BDAEDAE4E2024D0D25C63E44DCCF65622D4402DB4A2DF12868D1546503F" },
+  { name = "gleam_community_ansi", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "FE79E08BF97009729259B6357EC058315B6FBB916FAD1C2FF9355115FEB0D3A4" },
+  { name = "gleam_community_colour", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_community_colour", source = "hex", outer_checksum = "A49A5E3AE8B637A5ACBA80ECB9B1AFE89FD3D5351FF6410A42B84F666D40D7D5" },
+  { name = "gleam_erlang", version = "0.25.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "054D571A7092D2A9727B3E5D183B7507DAB0DA41556EC9133606F09C15497373" },
+  { name = "gleam_json", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "thoas"], otp_app = "gleam_json", source = "hex", outer_checksum = "8B197DD5D578EA6AC2C0D4BDC634C71A5BCA8E7DB5F47091C263ECB411A60DF3" },
+  { name = "gleam_otp", version = "0.10.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "0B04FE915ACECE539B317F9652CAADBBC0F000184D586AAAF2D94C100945D72B" },
+  { name = "gleam_package_interface", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_json", "gleam_stdlib"], otp_app = "gleam_package_interface", source = "hex", outer_checksum = "52A721BCA972C8099BB881195D821AAA64B9F2655BECC102165D5A1097731F01" },
+  { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
+  { name = "glearray", version = "0.2.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glearray", source = "hex", outer_checksum = "908154F695D330E06A37FAB2C04119E8F315D643206F8F32B6A6C14A8709FFF4" },
+  { name = "gleeunit", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D364C87AFEB26BDB4FB8A5ABDE67D635DC9FA52D6AB68416044C35B096C6882D" },
+  { name = "glint", version = "0.16.0", build_tools = ["gleam"], requirements = ["gleam_community_ansi", "gleam_community_colour", "gleam_stdlib", "snag"], otp_app = "glint", source = "hex", outer_checksum = "61B7E85CBB0CCD2FD8A9C7AE06CA97A80BF6537716F34362A39DF9C74967BBBC" },
+  { name = "repeatedly", version = "2.1.1", build_tools = ["gleam"], requirements = [], otp_app = "repeatedly", source = "hex", outer_checksum = "38808C3EC382B0CD981336D5879C24ECB37FCB9C1D1BD128F7A80B0F74404D79" },
+  { name = "simplifile", version = "1.5.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "EB9AA8E65E5C1E3E0FDCFC81BC363FD433CB122D7D062750FFDF24DE4AC40116" },
+  { name = "snag", version = "0.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "snag", source = "hex", outer_checksum = "54D32E16E33655346AA3E66CBA7E191DE0A8793D2C05284E3EFB90AD2CE92BCC" },
+  { name = "spinner", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_community_ansi", "gleam_erlang", "gleam_stdlib", "glearray", "repeatedly"], otp_app = "spinner", source = "hex", outer_checksum = "200BA3D4A04D468898E63C0D316E23F526E02514BC46454091975CB5BAE41E8F" },
+  { name = "thoas", version = "0.4.1", build_tools = ["rebar3"], requirements = [], otp_app = "thoas", source = "hex", outer_checksum = "4918D50026C073C4AB1388437132C77A6F6F7C8AC43C60C13758CC0ADCE2134E" },
+  { name = "tom", version = "0.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "tom", source = "hex", outer_checksum = "0831C73E45405A2153091226BF98FB485ED16376988602CC01A5FD086B82D577" },
+]
+
+[requirements]
+argv = { version = "~> 1.0" }
+filepath = { version = "~> 0.1" }
+fs = { version = "~> 8.6"}
+gleam_community_ansi = { version = "~> 1.4" }
+gleam_erlang = { version = "~> 0.25" }
+gleam_json = { version = "~> 1.0" }
+gleam_otp = { version = "~> 0.10" }
+gleam_package_interface = { version = "~> 1.0" }
+gleam_stdlib = { version = "~> 0.34 or ~> 1.0" }
+gleeunit = { version = "~> 1.0" }
+glint = { version = "0.16.0" }
+simplifile = { version = "~> 1.5" }
+spinner = { version = "~> 1.1" }
+tom = { version = "~> 0.3" }

priv/component-entry.mjs

···
+import { register } from '../dev/javascript/lustre/client-component.ffi.mjs';
+import { name, {component_name} as component } from '../dev/javascript/{app_name}/{module_path}.mjs';
+
+register(component(), name);

priv/entry-with-main.mjs

···
+import { main } from "../dev/javascript/{app_name}/{app_name}.mjs";
+
+main();

priv/entry-with-start.mjs

···
+import { start } from "../dev/javascript/lustre/lustre.mjs";
+import { main } from "../dev/javascript/{app_name}/{app_name}.mjs";
+
+start(main(), "#app", undefined);

priv/index-with-lustre-ui.html

···
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+    <title>🚧 {app_name}</title>
+
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/gh/lustre-labs/ui/priv/styles.css"
+    />
+    <script type="module" src="./index.mjs"></script>
+  </head>
+
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

priv/index.html

···
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+    <title>🚧 {app_name}</title>
+
+    <script type="module" src="./index.mjs"></script>
+  </head>
+
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

priv/tailwind.config.js

···
+module.exports = {
+  content: ["./src/**/*.{gleam,mjs}"],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};

src/lustre/dev.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import argv
+import glint
+import lustre_dev_tools/cli/add
+import lustre_dev_tools/cli/start
+
+// MAIN ------------------------------------------------------------------------
+
+pub fn main() {
+  let args = argv.load().arguments
+
+  glint.new()
+  |> glint.as_gleam_module
+  |> glint.with_name("lustre/dev")
+  |> glint.with_pretty_help(glint.default_pretty_help())
+  |> glint.add(at: ["add", "esbuild"], do: add.esbuild())
+  |> glint.add(at: ["add", "tailwind"], do: add.tailwind())
+  // |> glint.add(at: ["build", "app"], do: build.app())
+  // |> glint.add(at: ["build", "component"], do: build.component())
+  |> glint.add(at: ["start"], do: start.run())
+  |> glint.run(args)
+}

src/lustre_dev_tools/cli.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import gleam_community/ansi
+import gleam/erlang
+import gleam/result
+import gleam/io
+import gleam/string
+import simplifile
+import spinner.{type Spinner}
+
+// TYPES -----------------------------------------------------------------------
+
+pub opaque type Env {
+  Env(spinner: SpinnerStatus)
+}
+
+type SpinnerStatus {
+  Waiting
+  Running(spinner: Spinner, message: String)
+  Paused(spinner: Spinner)
+}
+
+///
+///
+pub type Cli(state, a, e) {
+  Cli(run: fn(Env, state) -> #(Env, state, Result(a, e)))
+}
+
+//
+
+///
+///
+pub fn run(step: Cli(state, a, e), with state: state) -> Result(a, e) {
+  let env = Env(spinner: Waiting)
+  let #(env, _, result) = step.run(env, state)
+
+  case env.spinner {
+    Waiting -> Nil
+    Running(spinner, _) -> spinner.stop(spinner)
+    Paused(spinner) -> spinner.stop(spinner)
+  }
+
+  result
+}
+
+//
+
+///
+///
+pub fn return(value: a) -> Cli(state, a, e) {
+  use env, state <- Cli
+
+  #(env, state, Ok(value))
+}
+
+///
+///
+pub fn throw(error: e, message: String) -> Cli(state, a, e) {
+  use env, state <- Cli
+
+  case env.spinner {
+    Waiting -> #(env, state, Error(error))
+    Running(spinner, _) -> {
+      spinner.stop(spinner)
+      io.println("❌ " <> ansi.red(message))
+
+      #(Env(Paused(spinner)), state, Error(error))
+    }
+    Paused(spinner) -> {
+      io.println("❌ " <> ansi.red(message))
+
+      #(Env(Paused(spinner)), state, Error(error))
+    }
+  }
+}
+
+pub fn from_result(result: Result(a, e)) -> Cli(state, a, e) {
+  use env, state <- Cli
+
+  #(env, state, result)
+}
+
+//
+
+///
+///
+pub fn do(
+  step: Cli(state, a, e),
+  then next: fn(a) -> Cli(state, b, e),
+) -> Cli(state, b, e) {
+  use env, state <- Cli
+  let #(env, state, result) = step.run(env, state)
+
+  case result {
+    Ok(value) -> next(value).run(env, state)
+    Error(error) -> {
+      case env.spinner {
+        Waiting -> Nil
+        Paused(_) -> Nil
+        Running(spinner, message) -> {
+          spinner.stop(spinner)
+          io.println("❌ " <> ansi.red(message))
+        }
+      }
+
+      #(env, state, Error(error))
+    }
+  }
+}
+
+pub fn map(step: Cli(state, a, e), then next: fn(a) -> b) -> Cli(state, b, e) {
+  use env, state <- Cli
+  let #(env, state, result) = step.run(env, state)
+  let result = result.map(result, next)
+
+  #(env, state, result)
+}
+
+pub fn map_error(
+  step: Cli(state, a, e),
+  then next: fn(e) -> f,
+) -> Cli(state, a, f) {
+  use env, state <- Cli
+  let #(env, state, result) = step.run(env, state)
+  let result = result.map_error(result, next)
+
+  #(env, state, result)
+}
+
+///
+/// 
+pub fn do_result(
+  result: Result(a, e),
+  then next: fn(a) -> Cli(state, b, e),
+) -> Cli(state, b, e) {
+  use env, state <- Cli
+
+  case result {
+    Ok(a) -> next(a).run(env, state)
+    Error(e) -> #(env, state, Error(e))
+  }
+}
+
+///
+///
+pub fn try(
+  step: Result(a, x),
+  catch recover: fn(x) -> e,
+  then next: fn(a) -> Cli(state, b, e),
+) -> Cli(state, b, e) {
+  use env, state <- Cli
+
+  case step {
+    Ok(value) -> next(value).run(env, state)
+    Error(error) -> {
+      case env.spinner {
+        Waiting -> Nil
+        Paused(_) -> Nil
+        Running(spinner, message) -> {
+          spinner.stop(spinner)
+          io.println("❌ " <> ansi.red(message))
+        }
+      }
+
+      #(env, state, Error(recover(error)))
+    }
+  }
+}
+
+//
+
+///
+///
+pub fn log(
+  message: String,
+  then next: fn() -> Cli(state, a, e),
+) -> Cli(state, a, e) {
+  use env, state <- Cli
+  let env =
+    Env(spinner: case env.spinner {
+      Waiting ->
+        Running(
+          spinner.new(message)
+            |> spinner.with_frames(spinner.snake_frames)
+            |> spinner.start,
+          message,
+        )
+
+      Running(spinner, _) -> {
+        spinner.set_text(spinner, message)
+        Running(spinner, message)
+      }
+
+      Paused(spinner) -> {
+        spinner.set_text(spinner, message)
+        Running(spinner, message)
+      }
+    })
+
+  next().run(env, state)
+}
+
+pub fn success(
+  message: String,
+  then next: fn() -> Cli(state, a, e),
+) -> Cli(state, a, e) {
+  use env, state <- Cli
+  let env =
+    Env(spinner: case env.spinner {
+      Waiting -> Waiting
+      Paused(spinner) -> Paused(spinner)
+      Running(spinner, _) -> {
+        spinner.stop(spinner)
+        Paused(spinner)
+      }
+    })
+
+  io.println("✅ " <> ansi.green(message))
+  next().run(env, state)
+}
+
+//
+
+///
+///
+pub fn get_state() -> Cli(state, state, e) {
+  use env, state <- Cli
+
+  #(env, state, Ok(state))
+}
+
+///
+///
+pub fn set_state(value: state) -> Cli(state, Nil, e) {
+  use env, _ <- Cli
+
+  #(env, value, Ok(Nil))
+}
+
+//
+
+@external(erlang, "lustre_dev_tools_ffi", "exec")
+pub fn exec(
+  run command: String,
+  with args: List(String),
+  in in: String,
+) -> Result(String, #(Int, String))
+
+pub fn template(
+  name: String,
+  on_error: fn(String) -> e,
+  then next: fn(String) -> Cli(state, a, e),
+) -> Cli(state, a, e) {
+  use env, state <- Cli
+  let assert Ok(priv) = erlang.priv_directory("lustre_dev_tools")
+
+  case simplifile.read(priv <> "/" <> name) {
+    Ok(template) -> next(template).run(env, state)
+    Error(error) -> #(
+      env,
+      state,
+      Error(on_error(name <> ": " <> string.inspect(error))),
+    )
+  }
+}

src/lustre_dev_tools/cli/add.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import glint.{type Command, CommandInput}
+import glint/flag
+import lustre_dev_tools/esbuild
+import lustre_dev_tools/cli
+import lustre_dev_tools/tailwind
+
+// COMMANDS --------------------------------------------------------------------
+
+pub fn esbuild() -> Command(Nil) {
+  let description =
+    "
+Download a platform-appropriate version of the esbuild binary. Lustre uses this
+to bundle applications and act as a development server.
+    "
+
+  glint.command(fn(input) {
+    let CommandInput(flags: flags, ..) = input
+    let assert Ok(os) = flag.get_string(flags, "os")
+    let assert Ok(cpu) = flag.get_string(flags, "cpu")
+    let script = esbuild.download(os, cpu)
+
+    case cli.run(script, Nil) {
+      Ok(_) -> Nil
+      Error(error) -> esbuild.explain(error)
+    }
+  })
+  |> glint.description(description)
+  |> glint.unnamed_args(glint.EqArgs(0))
+  |> glint.flag("os", {
+    let description = ""
+    let default = get_os()
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("cpu", {
+    let description = ""
+    let default = get_cpu()
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+}
+
+pub fn tailwind() -> Command(Nil) {
+  let description =
+    "
+Download a platform-appropriate version of the Tailwind binary.
+    "
+
+  glint.command(fn(input) {
+    let CommandInput(flags: flags, ..) = input
+    let assert Ok(os) = flag.get_string(flags, "os")
+    let assert Ok(cpu) = flag.get_string(flags, "cpu")
+    let script = tailwind.setup(os, cpu)
+
+    case cli.run(script, Nil) {
+      Ok(_) -> Nil
+      Error(error) -> tailwind.explain(error)
+    }
+  })
+  |> glint.description(description)
+  |> glint.unnamed_args(glint.EqArgs(0))
+  |> glint.flag("os", {
+    let description = ""
+    let default = get_os()
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("cpu", {
+    let description = ""
+    let default = get_cpu()
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+}
+
+// EXTERNALS -------------------------------------------------------------------
+
+@external(erlang, "lustre_dev_tools_ffi", "get_os")
+fn get_os() -> String
+
+@external(erlang, "lustre_dev_tools_ffi", "get_cpu")
+fn get_cpu() -> String

src/lustre_dev_tools/cli/build.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import filepath
+import gleam/bool
+import gleam/dict
+import gleam/io
+import gleam/list
+import gleam/package_interface.{type Type, Named, Variable}
+import gleam/result
+import gleam/string
+import glint.{type Command, CommandInput}
+import glint/flag
+import lustre_dev_tools/esbuild
+import lustre_dev_tools/project.{type Module}
+import lustre_dev_tools/cli.{type Cli}
+import lustre_dev_tools/tailwind
+import simplifile
+
+// COMMANDS --------------------------------------------------------------------
+
+pub fn app() -> Command(Nil) {
+  let description =
+    "
+Build and bundle an entire Lustre application. The generated JavaScript module
+calls your app's `main` function on page load and can be included in any Web
+page without Gleam or Lustre being present.
+
+This is different from using `gleam build` directly because it produces a single
+JavaScript module for you to host or distribute.
+    "
+
+  glint.command(fn(input) {
+    let CommandInput(flags: flags, ..) = input
+    let assert Ok(minify) = flag.get_bool(flags, "minify")
+
+    let script = {
+      use <- cli.log("Building your project")
+      use project_name <- cli.do_result(get_project_name())
+      use <- cli.success("Project compiled successfully")
+      use <- cli.log("Checking if I can bundle your application")
+      use module <- cli.do_result(get_module_interface(project_name))
+      use _ <- cli.do_result(check_main_function(project_name, module))
+
+      use <- cli.log("Creating the bundle entry file")
+      let root = project.root()
+      let tempdir = filepath.join(root, "build/.lustre")
+      let outdir = filepath.join(root, "priv/static")
+      let _ = simplifile.create_directory_all(tempdir)
+      let _ = simplifile.create_directory_all(outdir)
+      use template <- cli.template("entry-with-main.mjs", InternalError)
+      let entry = string.replace(template, "{app_name}", project_name)
+
+      let entryfile = filepath.join(tempdir, "entry.mjs")
+      let ext = case minify {
+        True -> ".min.mjs"
+        False -> ".mjs"
+      }
+
+      let outfile =
+        project_name
+        |> string.append(ext)
+        |> filepath.join(outdir, _)
+
+      let assert Ok(_) = simplifile.write(entryfile, entry)
+
+      use _ <- cli.do(bundle(entry, tempdir, outfile, minify))
+      use entry <- cli.template("entry.css", InternalError)
+      let outfile =
+        filepath.strip_extension(outfile)
+        |> string.append(".css")
+
+      let bundle = bundle_tailwind(entry, tempdir, outfile, minify)
+      use _ <- cli.do(cli.map_error(bundle, TailwindBundleError))
+
+      cli.return(Nil)
+    }
+
+    case cli.run(script, Nil) {
+      Ok(_) -> Nil
+      Error(error) -> explain(error)
+    }
+  })
+  |> glint.description(description)
+  |> glint.unnamed_args(glint.EqArgs(0))
+  |> glint.flag("minify", {
+    let description = "Minify the output"
+    let default = False
+
+    flag.bool()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+}
+
+pub fn component() -> Command(Nil) {
+  let description =
+    "
+Build a Lustre component as a portable Web Component. The generated JavaScript
+module can be included in any Web page and used without Gleam or Lustre being
+present.
+  "
+
+  glint.command(fn(input) {
+    let CommandInput(flags: flags, named_args: args, ..) = input
+    let assert Ok(module_path) = dict.get(args, "module_path")
+    let assert Ok(minify) = flag.get_bool(flags, "minify")
+
+    let script = {
+      use <- cli.log("Building your project")
+      use module <- cli.do_result(get_module_interface(module_path))
+      use <- cli.success("Project compiled successfully")
+      use <- cli.log("Checking if I can bundle your component")
+      use _ <- cli.do_result(check_component_name(module_path, module))
+      use component <- cli.do_result(find_component(module_path, module))
+
+      use <- cli.log("Creating the bundle entry file")
+      let root = project.root()
+      let tempdir = filepath.join(root, "build/.lustre")
+      let outdir = filepath.join(root, "priv/static")
+      let _ = simplifile.create_directory_all(tempdir)
+      let _ = simplifile.create_directory_all(outdir)
+
+      use project_name <- cli.do_result(get_project_name())
+
+      // Esbuild bundling
+      use template <- cli.template("component-entry.mjs", InternalError)
+      let entry =
+        template
+        |> string.replace("{component_name}", component)
+        |> string.replace("{app_name}", project_name)
+        |> string.replace("{module_path}", module_path)
+
+      let entryfile = filepath.join(tempdir, "entry.mjs")
+      let ext = case minify {
+        True -> ".min.mjs"
+        False -> ".mjs"
+      }
+      let assert Ok(outfile) =
+        string.split(module_path, "/")
+        |> list.last
+        |> result.map(string.append(_, ext))
+        |> result.map(filepath.join(outdir, _))
+
+      let assert Ok(_) = simplifile.write(entryfile, entry)
+      use _ <- cli.do(bundle(entry, tempdir, outfile, minify))
+
+      // Tailwind bundling
+      use entry <- cli.template("entry.css", InternalError)
+      let outfile =
+        filepath.strip_extension(outfile)
+        |> string.append(".css")
+
+      let bundle = bundle_tailwind(entry, tempdir, outfile, minify)
+      use _ <- cli.do(cli.map_error(bundle, TailwindBundleError))
+
+      cli.return(Nil)
+    }
+
+    case cli.run(script, Nil) {
+      Ok(_) -> Nil
+      Error(error) -> explain(error)
+    }
+  })
+  |> glint.description(description)
+  |> glint.named_args(["module_path"])
+  |> glint.unnamed_args(glint.EqArgs(0))
+  |> glint.flag("minify", {
+    let description = "Minify the output"
+    let default = False
+
+    flag.bool()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+}
+
+// ERROR HANDLING --------------------------------------------------------------
+
+type Error {
+  BuildError
+  BundleError(esbuild.Error)
+  TailwindBundleError(tailwind.Error)
+  ComponentMissing(module: String)
+  MainMissing(module: String)
+  ModuleMissing(module: String)
+  NameIncorrectType(module: String, got: Type)
+  NameMissing(module: String)
+  InternalError(message: String)
+}
+
+fn explain(error: Error) -> Nil {
+  case error {
+    BuildError -> project.explain(project.BuildError)
+
+    BundleError(error) -> esbuild.explain(error)
+
+    TailwindBundleError(error) -> tailwind.explain(error)
+
+    ComponentMissing(module) -> io.println("
+Module `" <> module <> "` doesn't have any public function I can use to bundle
+a component.
+
+To bundle a component your module should have a public function that returns a
+Lustre `App`:
+
+  import lustre.{type App}
+  pub fn my_component() -> App(flags, model, msg) {
+    todo as \"your Lustre component to bundle\"
+  }
+")
+
+    MainMissing(module) -> io.println("
+Module `" <> module <> "` doesn't have a public `main` function I can use as
+the bundle entry point.")
+
+    ModuleMissing(module) -> io.println("
+I couldn't find a public module called `" <> module <> "` in your project.")
+
+    NameIncorrectType(module, type_) -> io.println("
+I can't use the `name` constant exposed by module `" <> module <> "`
+to give a name to the component I'm bundling.
+I was expecting `name` to be a `String`,
+but it has type `" <> project.type_to_string(type_) <> "`.")
+
+    NameMissing(module) -> io.println("
+Module `" <> module <> "` doesn't have a public `name` constant.
+That is required so that I can give a proper name to the component I'm bundling.
+
+Try adding a `name` constant to your module like this:
+
+  const name: String = \"component-name\"")
+
+    InternalError(message) -> io.println("
+I ran into an error I wasn't expecting. Please open an issue on GitHub at
+https://github.com/lustre-labs/cli with the following message:
+" <> message)
+  }
+}
+
+// STEPS -----------------------------------------------------------------------
+
+fn get_project_name() -> Result(String, Error) {
+  project.config()
+  |> result.replace_error(BuildError)
+  |> result.map(fn(confg) { confg.name })
+}
+
+fn get_module_interface(module_path: String) -> Result(Module, Error) {
+  project.interface()
+  |> result.replace_error(BuildError)
+  |> result.then(fn(interface) {
+    dict.get(interface.modules, module_path)
+    |> result.replace_error(ModuleMissing(module_path))
+  })
+}
+
+fn check_main_function(
+  module_path: String,
+  module: Module,
+) -> Result(Nil, Error) {
+  case dict.has_key(module.functions, "main") {
+    True -> Ok(Nil)
+    False -> Error(MainMissing(module_path))
+  }
+}
+
+fn check_component_name(
+  module_path: String,
+  module: Module,
+) -> Result(Nil, Error) {
+  dict.get(module.constants, "name")
+  |> result.replace_error(NameMissing(module_path))
+  |> result.then(fn(component_name) {
+    case is_string_type(component_name) {
+      True -> Ok(Nil)
+      False -> Error(NameIncorrectType(module_path, component_name))
+    }
+  })
+}
+
+fn find_component(module_path: String, module: Module) -> Result(String, Error) {
+  let functions = dict.to_list(module.functions)
+  let error = Error(ComponentMissing(module_path))
+
+  use _, #(name, t) <- list.fold_until(functions, error)
+  case t.parameters, is_compatible_app_type(t.return) {
+    [], True -> list.Stop(Ok(name))
+    _, _ -> list.Continue(error)
+  }
+}
+
+fn bundle(
+  entry: String,
+  tempdir: String,
+  outfile: String,
+  minify: Bool,
+) -> Cli(any, Nil, Error) {
+  let entryfile = filepath.join(tempdir, "entry.mjs")
+  let assert Ok(_) = simplifile.write(entryfile, entry)
+  use _ <- cli.do(
+    esbuild.bundle(entryfile, outfile, minify)
+    |> cli.map_error(BundleError),
+  )
+
+  cli.return(Nil)
+}
+
+fn bundle_tailwind(
+  entry: String,
+  tempdir: String,
+  outfile: String,
+  minify: Bool,
+) -> Cli(any, Nil, tailwind.Error) {
+  // We first check if there's a `tailwind.config.js` at the project's root.
+  // If not present we do nothing; otherwise we go on with bundling.
+  let root = project.root()
+  let tailwind_config_file = filepath.join(root, "tailwind.config.js")
+  let has_tailwind_config =
+    simplifile.verify_is_file(tailwind_config_file)
+    |> result.unwrap(False)
+  use <- bool.guard(when: !has_tailwind_config, return: cli.return(Nil))
+
+  use _ <- cli.do(tailwind.setup(get_os(), get_cpu()))
+
+  use <- cli.log("Bundling with Tailwind")
+  let entryfile = filepath.join(tempdir, "entry.css")
+  let assert Ok(_) = simplifile.write(entryfile, entry)
+
+  let flags = ["--watch", "--input=" <> entryfile, "--output=" <> outfile]
+  let options = case minify {
+    True -> ["--minify", ..flags]
+    False -> flags
+  }
+  use _ <- cli.try(
+    cli.exec("./build/.lustre/bin/tailwind", in: root, with: options),
+    fn(pair) { tailwind.BundleError(pair.1) },
+  )
+  use <- cli.success("Bundle produced at `" <> outfile <> "`")
+
+  cli.return(Nil)
+}
+
+// UTILS -----------------------------------------------------------------------
+
+fn is_string_type(t: Type) -> Bool {
+  case t {
+    Named(name: "String", package: "", module: "gleam", parameters: []) -> True
+    _ -> False
+  }
+}
+
+fn is_nil_type(t: Type) -> Bool {
+  case t {
+    Named(name: "Nil", package: "", module: "gleam", parameters: []) -> True
+    _ -> False
+  }
+}
+
+fn is_type_variable(t: Type) -> Bool {
+  case t {
+    Variable(..) -> True
+    _ -> False
+  }
+}
+
+fn is_compatible_app_type(t: Type) -> Bool {
+  case t {
+    Named(
+      name: "App",
+      package: "lustre",
+      module: "lustre",
+      parameters: [flags, ..],
+    ) -> is_nil_type(flags) || is_type_variable(flags)
+    _ -> False
+  }
+}
+
+// EXTERNALS -------------------------------------------------------------------
+
+@external(erlang, "cli_ffi", "get_os")
+fn get_os() -> String
+
+@external(erlang, "cli_ffi", "get_cpu")
+fn get_cpu() -> String

src/lustre_dev_tools/cli/start.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import filepath
+import gleam/dict
+import gleam/io
+import gleam/package_interface.{type Type, Fn, Named, Variable}
+import gleam/result
+import gleam/string
+import glint.{type Command, CommandInput}
+import glint/flag
+import lustre_dev_tools/cli
+import lustre_dev_tools/esbuild
+import lustre_dev_tools/project.{type Module}
+import simplifile
+
+// COMMANDS --------------------------------------------------------------------
+
+pub fn run() -> Command(Nil) {
+  let description =
+    "
+    "
+
+  glint.command(fn(input) {
+    let CommandInput(flags: flags, ..) = input
+    let assert Ok(host) = flag.get_string(flags, "host")
+    let assert Ok(port) = flag.get_string(flags, "port")
+    let assert Ok(use_lustre_ui) = flag.get_bool(flags, "use-lustre-ui")
+    let assert Ok(spa) = flag.get_bool(flags, "spa")
+    let custom_html = flag.get_string(flags, "html")
+
+    let script = {
+      use <- cli.log("Building your project")
+      use interface <- cli.try(project.interface(), fn(_) { BuildError })
+      use module <- cli.try(dict.get(interface.modules, interface.name), fn(_) {
+        ModuleMissing(interface.name)
+      })
+      use is_app <- cli.do_result(check_is_lustre_app(interface.name, module))
+      use <- cli.success("Project compiled successfully")
+
+      use <- cli.log("Creating the application entry point")
+      let root = project.root()
+      let tempdir = filepath.join(root, "build/.lustre")
+      let _ = simplifile.create_directory_all(tempdir)
+      use template <- cli.template(
+        case is_app {
+          True -> "entry-with-start.mjs"
+          False -> "entry-with-main.mjs"
+        },
+        InternalError,
+      )
+
+      let entry = string.replace(template, "{app_name}", interface.name)
+      use html <- cli.do(case custom_html {
+        Ok(custom_html_path) ->
+          custom_html_path
+          |> simplifile.read
+          |> result.map_error(CouldntOpenCustomHtml(_, custom_html_path))
+          |> result.map(string.replace(
+            _,
+            "<script type=\"application/lustre\">",
+            "<script type=\"module\" src=\"./index.mjs\">",
+          ))
+          |> cli.from_result
+
+        Error(_) if use_lustre_ui -> {
+          let name = "index-with-lustre-ui.html"
+          use template <- cli.template(name, InternalError)
+          let html = string.replace(template, "{app_name}", interface.name)
+
+          cli.return(html)
+        }
+
+        _ -> {
+          let name = "index.html"
+          use template <- cli.template(name, InternalError)
+          let html = string.replace(template, "{app_name}", interface.name)
+
+          cli.return(html)
+        }
+      })
+
+      let assert Ok(_) = simplifile.write(tempdir <> "/entry.mjs", entry)
+      let assert Ok(_) = simplifile.write(tempdir <> "/index.html", html)
+
+      use _ <- cli.do(
+        esbuild.bundle(
+          filepath.join(tempdir, "entry.mjs"),
+          filepath.join(tempdir, "index.mjs"),
+          False,
+        )
+        |> cli.map_error(BundleError),
+      )
+
+      use _ <- cli.do(
+        esbuild.serve(host, port, spa)
+        |> cli.map_error(BundleError),
+      )
+
+      cli.return(Nil)
+    }
+
+    case cli.run(script, Nil) {
+      Ok(_) -> Nil
+      Error(error) -> explain(error)
+    }
+  })
+  |> glint.description(description)
+  |> glint.unnamed_args(glint.EqArgs(0))
+  |> glint.flag("host", {
+    let description = ""
+    let default = "localhost"
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("port", {
+    let description = ""
+    let default = "1234"
+
+    flag.string()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("use-lustre-ui", {
+    let description = "Inject lustre/ui's stylesheet. Ignored if --html is set."
+    let default = False
+
+    flag.bool()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("spa", {
+    let description =
+      "Serve your app on any route. Useful for apps that do client-side routing."
+    let default = False
+
+    flag.bool()
+    |> flag.default(default)
+    |> flag.description(description)
+  })
+  |> glint.flag("html", {
+    let description =
+      "Supply a custom HTML file to use as the entry point.
+To inject the Lustre bundle, make sure it includes the following empty script: 
+<script type=\"application/lustre\"></script>
+ "
+      |> string.trim_right
+
+    flag.string()
+    |> flag.description(description)
+  })
+}
+
+// ERROR HANDLING --------------------------------------------------------------
+
+type Error {
+  BuildError
+  BundleError(esbuild.Error)
+  CouldntOpenCustomHtml(error: simplifile.FileError, path: String)
+  MainMissing(module: String)
+  MainIncorrectType(module: String, got: Type)
+  MainBadAppType(module: String, got: Type)
+  ModuleMissing(module: String)
+  InternalError(message: String)
+}
+
+fn explain(error: Error) -> Nil {
+  case error {
+    BuildError -> project.explain(project.BuildError)
+
+    BundleError(error) -> esbuild.explain(error)
+
+    CouldntOpenCustomHtml(_, path) -> io.println("
+I couldn't open the custom HTML file at `" <> path <> "`.")
+
+    MainMissing(module) -> io.println("
+Module `" <> module <> "` doesn't have a public `main` function I can preview.")
+
+    MainIncorrectType(module, type_) -> io.println("
+I cannot preview the `main` function exposed by module `" <> module <> "`.
+To start a preview server I need it to take no arguments and return a Lustre
+`App`.
+The one I found has type `" <> project.type_to_string(type_) <> "`.")
+
+    // TODO: maybe this could have useful links to `App`/flags...
+    MainBadAppType(module, type_) -> io.println("
+I cannot preview the `main` function exposed by module `" <> module <> "`.
+To start a preview server I need it to return a Lustre `App` that doesn't need
+any flags.
+The one I found has type `" <> project.type_to_string(type_) <> "`.
+
+Its return type should look something like this:
+
+  import lustre.{type App}
+  pub fn main() -> App(flags, model, msg) {
+    todo as \"your Lustre application to preview\"
+  }")
+
+    ModuleMissing(module) -> io.println("
+I couldn't find a public module called `" <> module <> "` in your project.")
+
+    InternalError(message) -> io.println("
+I ran into an error I wasn't expecting. Please open an issue on GitHub at
+https://github.com/lustre-labs/cli with the following message:
+" <> message)
+  }
+}
+
+// STEPS -----------------------------------------------------------------------
+
+fn check_is_lustre_app(
+  module_path: String,
+  module: Module,
+) -> Result(Bool, Error) {
+  dict.get(module.functions, "main")
+  |> result.replace_error(MainMissing(module_path))
+  |> result.then(fn(main) {
+    case main.parameters, main.return {
+      [_, ..], _ ->
+        Error(MainIncorrectType(module_path, Fn(main.parameters, main.return)))
+
+      [], Named(
+        name: "App",
+        package: "lustre",
+        module: "lustre",
+        parameters: [flags, ..],
+      ) ->
+        case is_compatible_flags_type(flags) {
+          True -> Ok(True)
+          False -> Error(MainBadAppType(module_path, main.return))
+        }
+
+      [], _ -> Ok(False)
+    }
+  })
+}
+
+// UTILS -----------------------------------------------------------------------
+
+fn is_nil_type(t: Type) -> Bool {
+  case t {
+    Named(name: "Nil", package: "", module: "gleam", parameters: []) -> True
+    _ -> False
+  }
+}
+
+fn is_type_variable(t: Type) -> Bool {
+  case t {
+    Variable(..) -> True
+    _ -> False
+  }
+}
+
+fn is_compatible_flags_type(t: Type) -> Bool {
+  is_nil_type(t) || is_type_variable(t)
+}

src/lustre_dev_tools/esbuild.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import filepath
+import gleam/dynamic.{type Dynamic}
+import gleam/io
+import gleam/list
+import gleam/result
+import gleam/set
+import gleam/string
+import lustre_dev_tools/cli.{type Cli}
+import lustre_dev_tools/project
+import simplifile.{type FilePermissions, Execute, FilePermissions, Read, Write}
+
+// COMMANDS --------------------------------------------------------------------
+
+pub fn download(os: String, cpu: String) -> Cli(any, Nil, Error) {
+  use <- cli.log("Downloading esbuild")
+
+  let outdir = filepath.join(project.root(), "build/.lustre/bin")
+  let outfile = filepath.join(outdir, "esbuild")
+
+  case check_esbuild_exists(outfile) {
+    True -> cli.success("Esbuild already installed!", fn() { cli.return(Nil) })
+    False -> {
+      use <- cli.log("Detecting platform")
+      use url <- cli.do_result(get_download_url(os, cpu))
+
+      use <- cli.log("Downloading from " <> url)
+      use tarball <- cli.try(get_esbuild(url), NetworkError)
+
+      use <- cli.log("Unzipping esbuild")
+      use bin <- cli.try(unzip_esbuild(tarball), UnzipError)
+      use _ <- cli.try(write_esbuild(bin, outdir, outfile), SimplifileError(
+        _,
+        outfile,
+      ))
+      use _ <- cli.try(set_filepermissions(outfile), SimplifileError(_, outfile))
+
+      use <- cli.success("Esbuild installed!")
+      cli.return(Nil)
+    }
+  }
+}
+
+pub fn bundle(
+  input_file: String,
+  output_file: String,
+  minify: Bool,
+) -> Cli(any, Nil, Error) {
+  use _ <- cli.do(download(get_os(), get_cpu()))
+  use _ <- cli.try(project.build(), fn(_) { BuildError })
+  use <- cli.log("Getting everything ready for tree shaking")
+
+  let root = project.root()
+  use _ <- cli.try(configure_node_tree_shaking(root), SimplifileError(_, root))
+
+  let flags = [
+    "--bundle",
+    "--external:node:*",
+    "--format=esm",
+    "--outfile=" <> output_file,
+  ]
+  let options = case minify {
+    True -> [input_file, "--minify", ..flags]
+    False -> [input_file, ..flags]
+  }
+
+  use <- cli.log("Bundling with esbuild")
+  use _ <- cli.try(
+    cli.exec(run: "./build/.lustre/bin/esbuild", in: root, with: options),
+    fn(pair) { BundleError(pair.1) },
+  )
+
+  use <- cli.success("Bundle produced at `" <> output_file <> "`")
+  cli.return(Nil)
+}
+
+pub fn serve(host: String, port: String, spa: Bool) -> Cli(any, Nil, Error) {
+  use _ <- cli.do(download(get_os(), get_cpu()))
+  let root = project.root()
+  let flags = [
+    "--serve=" <> host <> ":" <> port,
+    "--servedir=" <> filepath.join(root, "build/.lustre"),
+  ]
+
+  let options = case spa {
+    True -> [
+      "--serve-fallback=" <> filepath.join(root, "build/.lustre/index.html"),
+      ..flags
+    ]
+    False -> flags
+  }
+
+  use <- cli.success("Starting dev server at " <> host <> ":" <> port <> "...")
+  use _ <- cli.try(
+    cli.exec(run: "./build/.lustre/bin/esbuild", in: root, with: options),
+    fn(pair) { BundleError(pair.1) },
+  )
+
+  cli.return(Nil)
+}
+
+// STEPS -----------------------------------------------------------------------
+
+fn check_esbuild_exists(path) {
+  case simplifile.verify_is_file(path) {
+    Ok(True) -> True
+    Ok(False) | Error(_) -> False
+  }
+}
+
+fn get_download_url(os, cpu) {
+  let base = "https://registry.npmjs.org/@esbuild/"
+  let path = case os, cpu {
+    "android", "arm" -> Ok("android-arm/-/android-arm-0.19.10.tgz")
+    "android", "arm64" -> Ok("android-arm64/-/android-arm64-0.19.10.tgz")
+    "android", "x64" -> Ok("android-x64/-/android-x64-0.19.10.tgz")
+
+    "darwin", "aarch64" -> Ok("darwin-arm64/-/darwin-arm64-0.19.10.tgz")
+    "darwin", "amd64" -> Ok("darwin-arm64/-/darwin-arm64-0.19.10.tgz")
+    "darwin", "arm64" -> Ok("darwin-arm64/-/darwin-arm64-0.19.10.tgz")
+    "darwin", "x86_64" -> Ok("darwin-x64/-/darwin-x64-0.19.10.tgz")
+
+    "freebsd", "arm64" -> Ok("freebsd-arm64/-/freebsd-arm64-0.19.10.tgz")
+    "freebsd", "x64" -> Ok("freebsd-x64/-/freebsd-x64-0.19.10.tgz")
+
+    "linux", "aarch64" -> Ok("linux-arm64/-/linux-arm64-0.19.10.tgz")
+    "linux", "arm" -> Ok("linux-arm/-/linux-arm-0.19.10.tgz")
+    "linux", "arm64" -> Ok("linux-arm64/-/linux-arm64-0.19.10.tgz")
+    "linux", "ia32" -> Ok("linux-ia32/-/linux-ia32-0.19.10.tgz")
+    "linux", "x64" -> Ok("linux-x64/-/linux-x64-0.19.10.tgz")
+    "linux", "x86_64" -> Ok("linux-x64/-/linux-x64-0.19.10.tgz")
+
+    "win32", "arm64" -> Ok("win32-arm64/-/win32-arm64-0.19.10.tgz")
+    "win32", "ia32" -> Ok("win32-ia32/-/win32-ia32-0.19.10.tgz")
+    "win32", "x64" -> Ok("win32-x64/-/win32-x64-0.19.10.tgz")
+    "win32", "x86_64" -> Ok("win32-x64/-/win32-x64-0.19.10.tgz")
+
+    "netbsd", "x64" -> Ok("netbsd-x64/-/netbsd-x64-0.19.10.tgz")
+    "openbsd", "x64" -> Ok("openbsd-x64/-/openbsd-x64-0.19.10.tgz")
+    "sunos", "x64" -> Ok("sunos-x64/-/sunos-x64-0.19.10.tgz")
+
+    _, _ -> Error(UnknownPlatform(os, cpu))
+  }
+
+  result.map(path, string.append(base, _))
+}
+
+fn write_esbuild(bin, outdir, outfile) {
+  let _ = simplifile.create_directory_all(outdir)
+
+  simplifile.write_bits(outfile, bin)
+}
+
+fn set_filepermissions(file) {
+  let permissions =
+    FilePermissions(
+      user: set.from_list([Read, Write, Execute]),
+      group: set.from_list([Read, Execute]),
+      other: set.from_list([Read, Execute]),
+    )
+
+  simplifile.set_permissions(file, permissions)
+}
+
+fn configure_node_tree_shaking(root) {
+  // This whole chunk of code is to force tree shaking on dependencies that esbuild
+  // has a habit of including because it thinks their imports might have side
+  // effects.
+  //
+  // This is a really grim hack but it's the only way I've found to get esbuild to
+  // ignore unused deps like `glint` that imports node stuff but aren't used in
+  // app code.
+  let force_tree_shaking = "{ \"sideEffects\": false }"
+  let assert Ok(_) =
+    simplifile.write(
+      filepath.join(root, "build/dev/javascript/package.json"),
+      force_tree_shaking,
+    )
+  let pure_deps = ["lustre", "glint", "simplifile"]
+
+  list.try_each(pure_deps, fn(dep) {
+    root
+    |> filepath.join("build/dev/javascript/" <> dep)
+    |> filepath.join("package.json")
+    |> simplifile.write(force_tree_shaking)
+  })
+}
+
+// ERROR HANDLING --------------------------------------------------------------
+
+pub type Error {
+  BuildError
+  BundleError(message: String)
+  NetworkError(Dynamic)
+  SimplifileError(reason: simplifile.FileError, path: String)
+  UnknownPlatform(os: String, cpu: String)
+  UnzipError(Dynamic)
+}
+
+pub fn explain(error: Error) -> Nil {
+  case error {
+    BuildError -> project.explain(project.BuildError)
+
+    BundleError(message) -> io.println("
+I ran into an error while trying to create a bundle with esbuild:
+" <> message)
+
+    // TODO: Is there a better way to deal with this dynamic error?
+    NetworkError(_dynamic) ->
+      io.println(
+        "
+There was a network error!",
+      )
+
+    // TODO: this could give a better error for some common reason like Enoent.
+    SimplifileError(reason, path) -> io.println("
+I ran into the following error at path `" <> path <> "`:" <> string.inspect(
+        reason,
+      ) <> ".")
+
+    UnknownPlatform(os, cpu) -> io.println("
+I couldn't figure out the correct esbuild version for your
+os (" <> os <> ") and cpu (" <> cpu <> ").")
+
+    // TODO: Is there a better way to deal with this dynamic error?
+    UnzipError(_dynamic) ->
+      io.println(
+        "
+I couldn't unzip the esbuild executable!",
+      )
+  }
+}
+
+// EXTERNALS -------------------------------------------------------------------
+
+@external(erlang, "lustre_dev_tools_ffi", "get_os")
+fn get_os() -> String
+
+@external(erlang, "lustre_dev_tools_ffi", "get_cpu")
+fn get_cpu() -> String
+
+@external(erlang, "lustre_dev_tools_ffi", "get_esbuild")
+fn get_esbuild(url: String) -> Result(BitArray, Dynamic)
+
+@external(erlang, "lustre_dev_tools_ffi", "unzip_esbuild")
+fn unzip_esbuild(tarball: BitArray) -> Result(BitArray, Dynamic)

src/lustre_dev_tools/project.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import filepath
+import gleam/dict.{type Dict}
+import gleam/dynamic.{type DecodeError, type Decoder, type Dynamic, DecodeError}
+import gleam/int
+import gleam/io
+import gleam/json
+import gleam/list
+import gleam/package_interface.{type Type, Fn, Named, Tuple, Variable}
+import gleam/pair
+import gleam/result
+import gleam/string
+import lustre_dev_tools/cli
+import simplifile
+import tom.{type Toml}
+
+// TYPES -----------------------------------------------------------------------
+
+pub type Config {
+  Config(name: String, version: String, toml: Dict(String, Toml))
+}
+
+pub type Interface {
+  Interface(name: String, version: String, modules: Dict(String, Module))
+}
+
+pub type Module {
+  Module(constants: Dict(String, Type), functions: Dict(String, Function))
+}
+
+pub type Function {
+  Function(parameters: List(Type), return: Type)
+}
+
+// COMMANDS --------------------------------------------------------------------
+
+/// Compile the current project running the `gleam build` command.
+///
+pub fn build() -> Result(Nil, String) {
+  cli.exec(run: "gleam", in: ".", with: ["build", "--target=js"])
+  |> result.map_error(pair.second)
+  |> result.replace(Nil)
+}
+
+pub fn interface() -> Result(Interface, String) {
+  let dir = filepath.join(root(), "build/.lustre")
+  let out = filepath.join(dir, "package-interface.json")
+  let args = ["export", "package-interface", "--out", out]
+
+  cli.exec(run: "gleam", in: ".", with: args)
+  |> result.map_error(pair.second)
+  |> result.then(fn(_) {
+    let assert Ok(json) = simplifile.read(out)
+    let assert Ok(interface) = json.decode(json, interface_decoder)
+
+    Ok(interface)
+  })
+}
+
+/// Read the project configuration in the `gleam.toml` file.
+///
+pub fn config() -> Result(Config, String) {
+  use _ <- result.try(build())
+
+  // Since we made sure that the project could compile we're sure that there is
+  // bound to be a `gleam.toml` file somewhere in the current directory (or in
+  // its parent directories). So we can safely call `root()` without
+  // it looping indefinitely.
+  let configuration_path = filepath.join(root(), "gleam.toml")
+
+  // All these operations are safe to assert because the Gleam project wouldn't
+  // compile if any of this stuff was invalid.
+  let assert Ok(configuration) = simplifile.read(configuration_path)
+  let assert Ok(toml) = tom.parse(configuration)
+  let assert Ok(name) = tom.get_string(toml, ["name"])
+  let assert Ok(version) = tom.get_string(toml, ["version"])
+
+  Ok(Config(name: name, version: version, toml: toml))
+}
+
+// ERROR HANDLING --------------------------------------------------------------
+
+///
+///
+pub type Error {
+  BuildError
+}
+
+pub fn explain(error: Error) -> Nil {
+  case error {
+    BuildError ->
+      "
+It looks like your project has some compilation errors that need to be addressed
+before I can do anything."
+      |> io.println
+  }
+}
+
+// UTILS -----------------------------------------------------------------------
+
+/// Finds the path leading to the project's root folder. This recursively walks
+/// up from the current directory until it finds a `gleam.toml`.
+///
+pub fn root() -> String {
+  find_root(".")
+}
+
+fn find_root(path: String) -> String {
+  let toml = filepath.join(path, "gleam.toml")
+
+  case simplifile.verify_is_file(toml) {
+    Ok(False) | Error(_) -> find_root(filepath.join("..", path))
+    Ok(True) -> path
+  }
+}
+
+pub fn type_to_string(type_: Type) -> String {
+  case type_ {
+    Tuple(elements) -> {
+      let elements = list.map(elements, type_to_string)
+      "#(" <> string.join(elements, with: ", ") <> ")"
+    }
+
+    Fn(params, return) -> {
+      let params = list.map(params, type_to_string)
+      let return = type_to_string(return)
+      "fn(" <> string.join(params, with: ", ") <> ") -> " <> return
+    }
+
+    Named(name, _package, _module, []) -> name
+    Named(name, _package, _module, params) -> {
+      let params = list.map(params, type_to_string)
+      name <> "(" <> string.join(params, with: ", ") <> ")"
+    }
+
+    Variable(id) -> "a_" <> int.to_string(id)
+  }
+}
+
+// DECODERS --------------------------------------------------------------------
+
+fn interface_decoder(dyn: Dynamic) -> Result(Interface, List(DecodeError)) {
+  dynamic.decode3(
+    Interface,
+    dynamic.field("name", dynamic.string),
+    dynamic.field("version", dynamic.string),
+    dynamic.field("modules", string_dict(module_decoder)),
+  )(dyn)
+}
+
+fn module_decoder(dyn: Dynamic) -> Result(Module, List(DecodeError)) {
+  dynamic.decode2(
+    Module,
+    dynamic.field(
+      "constants",
+      string_dict(dynamic.field("type", package_interface.type_decoder)),
+    ),
+    dynamic.field("functions", string_dict(function_decoder)),
+  )(dyn)
+}
+
+fn function_decoder(dyn: Dynamic) -> Result(Function, List(DecodeError)) {
+  dynamic.decode2(
+    Function,
+    dynamic.field("parameters", dynamic.list(labelled_argument_decoder)),
+    dynamic.field("return", package_interface.type_decoder),
+  )(dyn)
+}
+
+fn labelled_argument_decoder(dyn: Dynamic) -> Result(Type, List(DecodeError)) {
+  // In this case we don't really care about the label, so we're just ignoring
+  // it and returning the argument's type.
+  dynamic.field("type", package_interface.type_decoder)(dyn)
+}
+
+fn string_dict(values: Decoder(a)) -> Decoder(Dict(String, a)) {
+  dynamic.dict(dynamic.string, values)
+}

src/lustre_dev_tools/tailwind.gleam

···
+// IMPORTS ---------------------------------------------------------------------
+
+import filepath
+import gleam/bool
+import gleam/dynamic.{type Dynamic}
+import gleam/io
+import gleam/result
+import gleam/set
+import gleam/string
+import lustre_dev_tools/project
+import lustre_dev_tools/cli.{type Cli}
+import simplifile.{type FilePermissions, Execute, FilePermissions, Read, Write}
+
+const tailwind_version = "v3.4.1"
+
+// COMMANDS --------------------------------------------------------------------
+
+pub fn setup(os: String, cpu: String) -> Cli(any, Nil, Error) {
+  use _ <- cli.do(download(os, cpu, tailwind_version))
+  use _ <- cli.do(write_tailwind_config())
+
+  cli.return(Nil)
+}
+
+fn download(os: String, cpu: String, version: String) -> Cli(any, Nil, Error) {
+  use <- cli.log("Downloading Tailwind")
+
+  let root = project.root()
+  let outdir = filepath.join(root, "build/.lustre/bin")
+  let outfile = filepath.join(outdir, "tailwind")
+
+  case check_tailwind_exists(outfile) {
+    True -> cli.success("Tailwind already installed!", fn() { cli.return(Nil) })
+    False -> {
+      use <- cli.log("Detecting platform")
+      use url <- cli.do_result(get_download_url(os, cpu, version))
+
+      use <- cli.log("Downloading from " <> url)
+      use bin <- cli.try(get_tailwind(url), NetworkError)
+
+      use _ <- cli.try(write_tailwind(bin, outdir, outfile), fn(reason) {
+        CannotWriteTailwind(reason, outfile)
+      })
+      use _ <- cli.try(set_filepermissions(outfile), fn(reason) {
+        CannotSetPermissions(reason, outfile)
+      })
+
+      use <- cli.success("Tailwind installed!")
+
+      cli.return(Nil)
+    }
+  }
+}
+
+fn write_tailwind_config() -> Cli(any, Nil, Error) {
+  let config_filename = "tailwind.config.js"
+  let config_outfile = filepath.join(project.root(), config_filename)
+  let config_already_exists =
+    simplifile.verify_is_file(config_outfile)
+    |> result.unwrap(False)
+
+  // If there already is a configuration file, we make sure not to override it.
+  use <- bool.guard(when: config_already_exists, return: cli.return(Nil))
+  use <- cli.log("Writing `" <> config_filename <> "`")
+  use config <- cli.template("tailwind.config.js", InternalError)
+  use _ <- cli.try(
+    simplifile.write(to: config_outfile, contents: config),
+    CannotWriteConfig(_, config_outfile),
+  )
+  use <- cli.success("Written `" <> config_outfile <> "`")
+
+  cli.return(Nil)
+}
+
+// STEPS -----------------------------------------------------------------------
+
+fn check_tailwind_exists(path) {
+  case simplifile.verify_is_file(path) {
+    Ok(True) -> True
+    Ok(False) | Error(_) -> False
+  }
+}
+
+fn get_download_url(os, cpu, version) {
+  let base =
+    "https://github.com/tailwindlabs/tailwindcss/releases/download/"
+    <> version
+    <> "/tailwindcss-"
+
+  let path = case os, cpu {
+    "linux", "armv7" -> Ok("linux-armv7")
+    "linux", "arm64" -> Ok("linux-arm64")
+    "linux", "x64" | "linux", "x86_64" -> Ok("linux-x64")
+
+    "win32", "arm64" -> Ok("windows-arm64.exe")
+    "win32", "x64" | "win32", "x86_64" -> Ok("windows-x64.exe")
+
+    "darwin", "arm64" | "darwin", "aarch64" -> Ok("macos-arm64")
+    "darwin", "x64" | "darwin", "x86_64" -> Ok("macos-x64")
+
+    _, _ -> Error(UnknownPlatform(os, cpu))
+  }
+
+  result.map(path, string.append(base, _))
+}
+
+fn write_tailwind(bin, outdir, outfile) {
+  let _ = simplifile.create_directory_all(outdir)
+
+  simplifile.write_bits(outfile, bin)
+}
+
+fn set_filepermissions(file) {
+  let permissions =
+    FilePermissions(
+      user: set.from_list([Read, Write, Execute]),
+      group: set.from_list([Read, Execute]),
+      other: set.from_list([Read, Execute]),
+    )
+
+  simplifile.set_permissions(file, permissions)
+}
+
+// ERROR HANDLING --------------------------------------------------------------
+
+pub type Error {
+  NetworkError(Dynamic)
+  CannotWriteTailwind(reason: simplifile.FileError, path: String)
+  CannotSetPermissions(reason: simplifile.FileError, path: String)
+  CannotWriteConfig(reason: simplifile.FileError, path: String)
+  UnknownPlatform(os: String, cpu: String)
+  BundleError(reason: String)
+  InternalError(message: String)
+}
+
+pub fn explain(error: Error) -> Nil {
+  case error {
+    // TODO: Is there a better way to deal with this dynamic error?
+    NetworkError(_dynamic) ->
+      io.println(
+        "
+There was a network error!",
+      )
+
+    UnknownPlatform(os, cpu) -> io.println("
+I couldn't figure out the correct Tailwind version for your
+os (" <> os <> ") and cpu (" <> cpu <> ").")
+
+    CannotSetPermissions(reason, _) -> io.println("
+I ran into an error (" <> string.inspect(reason) <> ") when trying
+to set permissions for the Tailwind executable.
+")
+
+    CannotWriteConfig(reason, _) -> io.println("
+I ran into an error (" <> string.inspect(reason) <> ") when trying
+to write the `tailwind.config.js` file to the project's root.
+")
+
+    CannotWriteTailwind(reason, path) -> io.println("
+I ran into an error (" <> string.inspect(reason) <> ") when trying
+to write the Tailwind binary to
+  `" <> path <> "`.
+")
+
+    BundleError(reason) -> io.println("
+I ran into an error while trying to create a bundle with Tailwind:
+" <> reason)
+
+    InternalError(message) -> io.println("
+I ran into an error I wasn't expecting. Please open an issue on GitHub at
+https://github.com/lustre-labs/cli with the following message:
+" <> message)
+  }
+}
+
+// EXTERNALS -------------------------------------------------------------------
+
+@external(erlang, "lustre_dev_tools_ffi", "get_esbuild")
+fn get_tailwind(url: String) -> Result(BitArray, Dynamic)

src/lustre_dev_tools_ffi.erl

···
+-module(lustre_dev_tools_ffi).
+-export([
+    get_cpu/0,
+    get_esbuild/1,
+    get_tailwind/1,
+    get_os/0,
+    unzip_esbuild/1,
+    exec/3
+]).
+
+get_os() ->
+    case os:type() of
+        {win32, _} -> <<"win32">>;
+        {unix, darwin} -> <<"darwin">>;
+        {unix, linux} -> <<"linux">>;
+        {_, Unknown} -> atom_to_binary(Unknown, utf8)
+    end.
+
+get_cpu() ->
+    case erlang:system_info(os_type) of
+        {unix, _} ->
+            [Arch, _] = string:split(erlang:system_info(system_architecture), "-"),
+            list_to_binary(Arch);
+        {win32, _} ->
+            case erlang:system_info(wordsize) of
+                4 -> {ok, <<"ia32">>};
+                8 -> {ok, <<"x64">>}
+            end
+    end.
+
+get_esbuild(Url) ->
+    inets:start(),
+    ssl:start(),
+
+    case httpc:request(get, {Url, []}, [], [{body_format, binary}]) of
+        {ok, {{_, 200, _}, _, Zip}} -> {ok, Zip};
+        {ok, Res} -> {error, Res};
+        {error, Err} -> {error, Err}
+    end.
+
+get_tailwind(Url) ->
+    inets:start(),
+    ssl:start(),
+
+    case httpc:request(get, {Url, []}, [], [{body_format, binary}]) of
+        {ok, {{_, 200, _}, _, Bin}} -> {ok, Bin};
+        {ok, Res} -> {error, Res};
+        {error, Err} -> {error, Err}
+    end.
+
+unzip_esbuild(Zip) ->
+    Result =
+        erl_tar:extract({binary, Zip}, [
+            memory, compressed, {files, ["package/bin/esbuild"]}
+        ]),
+
+    case Result of
+        {ok, [{_, Esbuild}]} -> {ok, Esbuild};
+        {ok, Res} -> {error, Res};
+        {error, Err} -> {error, Err}
+    end.
+
+exec(Command, Args, Cwd) ->
+    Command_ = binary_to_list(Command),
+    Args_ = lists:map(fun(Arg) -> binary_to_list(Arg) end, Args),
+    Cwd_ = binary_to_list(Cwd),
+
+    Name = case Command_ of
+      "./" ++ _ -> {spawn_executable, Command_};
+      "/" ++ _ -> {spawn_executable, Command_};
+      _ -> {spawn_executable, os:find_executable(Command_)}
+    end,
+
+    Port = open_port(Name, [exit_status, binary, hide, stream, eof,
+        {args, Args_},
+        {cd, Cwd_}
+    ]),
+
+    do_exec(Port, []).
+
+do_exec(Port, Acc) ->
+    receive
+        {Port, {data, Data}} -> do_exec(Port, [Data | Acc]);
+        {Port, {exit_status, 0}} -> {ok, list_to_binary(lists:reverse(Acc))};
+        {Port, {exit_status, Code}} -> {error, {Code, list_to_binary(lists:reverse(Acc))}}
+    end.

test/lustre_dev_tools_test.gleam

···
+import gleeunit
+import gleeunit/should
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  1
+  |> should.equal(1)
+}