feat: windows support

Author: doorgan

apps/expert/lib/expert/engine_node.ex

@@ -52,7 +52,7 @@ defmodule Expert.EngineNode do
           IO.puts(\"ok\")
           """
           | path_append_arguments(paths)
-        ]
+        ] |> dbg()
 
       env =
         [
@@ -186,66 +186,86 @@ defmodule Expert.EngineNode do
     # Expert release, and we build it on the fly for the project elixir+opt
     # versions if it was not built yet.
     defp glob_paths(%Project{} = project) do
-      lsp = Expert.get_lsp()
-      project_name = Project.name(project)
-
       case Expert.Port.elixir_executable(project) do
         {:ok, elixir, env} ->
-          GenLSP.info(lsp, "Found elixir for #{project_name} at #{elixir}")
-
-          expert_priv = :code.priv_dir(:expert)
-          packaged_engine_source = Path.join([expert_priv, "engine_source", "apps", "engine"])
-
-          engine_source =
-            "EXPERT_ENGINE_PATH"
-            |> System.get_env(packaged_engine_source)
-            |> Path.expand()
-
-          build_engine_script = Path.join(expert_priv, "build_engine.exs")
-
-          opts =
-            [
-              :stderr_to_stdout,
-              args: [
-                elixir,
-                build_engine_script,
-                "--source-path",
-                engine_source,
-                "--vsn",
-                Expert.vsn()
-              ],
-              env: Expert.Port.ensure_charlists(env),
-              cd: Project.root_path(project)
-            ]
-
-          launcher = Expert.Port.path()
-
-          GenLSP.info(lsp, "Finding or building engine for project #{project_name}")
-
-          with_progress(project, "Building engine for #{project_name}", fn ->
-            fn ->
-              Process.flag(:trap_exit, true)
-
-              {:spawn_executable, launcher}
-              |> Port.open(opts)
-              |> wait_for_engine()
-            end
-            |> Task.async()
-            |> Task.await(:infinity)
-          end)
+          launch_engine_builder(project, elixir, env)
 
         {:error, :no_elixir, message} ->
           GenLSP.error(Expert.get_lsp(), message)
           Expert.terminate("Failed to find an elixir executable, shutting down", 1)
       end
     end
 
+    defp launch_engine_builder(project, elixir, env) do
+      lsp = Expert.get_lsp()
+
+      project_name = Project.name(project)
+      Logger.info("Found elixir for #{project_name} at #{elixir}")
+      GenLSP.info(lsp, "Found elixir for #{project_name} at #{elixir}")
+
+      expert_priv = :code.priv_dir(:expert)
+      packaged_engine_source = Path.join([expert_priv, "engine_source", "apps", "engine"])
+
+      engine_source =
+        "EXPERT_ENGINE_PATH"
+        |> System.get_env(packaged_engine_source)
+        |> Path.expand()
+
+      build_engine_script = Path.join(expert_priv, "build_engine.exs")
+
+      opts =
+        [
+          :stderr_to_stdout,
+          args: [
+            build_engine_script,
+            "--source-path",
+            engine_source,
+            "--vsn",
+            Expert.vsn()
+          ],
+          env: Expert.Port.ensure_charlists(env),
+          cd: Project.root_path(project)
+        ]
+
+      {launcher, opts} =
+        case :os.type() do
+          {:win32, _} ->
+            {elixir, opts}
+
+          {:unix, _} ->
+            launcher = Expert.Port.path()
+
+            opts =
+              Keyword.update(opts, :args, [elixir], fn old_args ->
+                [elixir | Enum.map(old_args, &to_string/1)]
+              end)
+
+            {launcher, opts}
+        end
+
+      GenLSP.info(lsp, "Finding or building engine for project #{project_name}")
+
+      with_progress(project, "Building engine for #{project_name}", fn ->
+        fn ->
+          Process.flag(:trap_exit, true)
+
+          {:spawn_executable, launcher}
+          |> Port.open(opts)
+          |> wait_for_engine()
+        end
+        |> Task.async()
+        |> Task.await(:infinity)
+      end)
+    end
+
     defp wait_for_engine(port, last_line \\ "") do
       receive do
         {^port, {:data, ~c"engine_path:" ++ engine_path}} ->
           engine_path = engine_path |> to_string() |> String.trim()
           Logger.info("Engine build available at: #{engine_path}")
 
+          Logger.info("ebin paths:\n#{inspect(ebin_paths(engine_path), pretty: true)}")
+
           {:ok, ebin_paths(engine_path)}
 
         {^port, {:data, data}} ->
@@ -374,6 +394,7 @@ defmodule Expert.EngineNode do
 
   @impl true
   def handle_info({_port, {:data, message}}, %State{} = state) do
+    dbg(message)
     Logger.debug("Node port message: #{to_string(message)}")
     {:noreply, state}
   end

apps/expert/lib/expert/port.ex

@@ -34,24 +34,50 @@ defmodule Expert.Port do
   end
 
   def elixir_executable(%Project{} = project) do
-    root_path = Project.root_path(project)
-
-    shell = System.get_env("SHELL")
-    path = path_env_at_directory(root_path, shell)
-
-    case :os.find_executable(~c"elixir", to_charlist(path)) do
-      false ->
-        {:error, :no_elixir,
-         "Couldn't find an elixir executable for project at #{root_path}. Using shell at #{shell} with PATH=#{path}"}
-
-      elixir ->
-        env =
-          Enum.map(System.get_env(), fn
-            {"PATH", _path} -> {"PATH", path}
-            other -> other
-          end)
-
-        {:ok, elixir, env}
+    case :os.type() do
+      {:win32, _} ->
+        # Remove the burrito binaries from PATH
+        path =
+          "PATH"
+          |> System.get_env()
+          |> String.split(";", parts: 2)
+          |> List.last()
+
+        case :os.find_executable(~c"elixir", to_charlist(path)) do
+          nil ->
+            {:error, :no_elixir, "Couldn't find an elixir executable"}
+
+          elixir ->
+            dbg(elixir)
+            env =
+              Enum.map(System.get_env(), fn
+                {"PATH", _path} -> {"PATH", path}
+                other -> other
+              end)
+
+            {:ok, elixir, env}
+        end
+
+      _ ->
+        root_path = Project.root_path(project)
+
+        shell = System.get_env("SHELL")
+        path = path_env_at_directory(root_path, shell)
+
+        case :os.find_executable(~c"elixir", to_charlist(path)) do
+          false ->
+            {:error, :no_elixir,
+             "Couldn't find an elixir executable for project at #{root_path}. Using shell at #{shell} with PATH=#{path}"}
+
+          elixir ->
+            env =
+              Enum.map(System.get_env(), fn
+                {"PATH", _path} -> {"PATH", path}
+                other -> other
+              end)
+
+            {:ok, elixir, env}
+        end
     end
   end
 
@@ -96,14 +122,11 @@ defmodule Expert.Port do
   Launches an executable in the project context via a port.
   """
   def open(%Project{} = project, executable, opts) do
-    {launcher, opts} = Keyword.pop_lazy(opts, :path, &path/0)
+    {os_type, _} = :os.type()
 
     opts =
       opts
       |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end)
-      |> Keyword.update(:args, [executable], fn old_args ->
-        [executable | Enum.map(old_args, &to_string/1)]
-      end)
 
     opts =
       if Keyword.has_key?(opts, :env) do
@@ -112,6 +135,24 @@ defmodule Expert.Port do
         opts
       end
 
+    open_port(os_type, executable, opts)
+  end
+
+  defp open_port(:win32, executable, opts) do
+    dbg("launching for windows")
+    dbg(opts)
+    Port.open({:spawn_executable, executable}, [:stderr_to_stdout | opts])
+  end
+
+  defp open_port(:unix, executable, opts) do
+    dbg(opts)
+    {launcher, opts} = Keyword.pop_lazy(opts, :path, &path/0)
+
+    opts =
+      Keyword.update(opts, :args, [executable], fn old_args ->
+        [executable | Enum.map(old_args, &to_string/1)]
+      end)
+
     Port.open({:spawn_executable, launcher}, [:stderr_to_stdout | opts])
   end
 

justfile

@@ -2,13 +2,21 @@ os := if os() == "macos" { "darwin" } else { os() }
 arch := if arch() =~ "(arm|aarch64)" { "arm64" } else { if arch() =~ "(x86|x86_64)" { "amd64" } else { "unsupported" } }
 local_target := if os =~ "(darwin|linux|windows)" { os + "_" + arch } else { "unsupported" }
 apps := "expert engine forge expert_credo"
+expert_erl_flags := "-start_epmd false -epmd_module Elixir.Forge.EPMD"
+engine_erl_flags := "-start_epmd false -epmd_module Elixir.Forge.EPMD"
 
 [doc('Run mix deps.get for the given project')]
+[unix]
 deps project:
     #!/usr/bin/env bash
     cd apps/{{ project }}
     mix deps.get
 
+[windows]
+deps project:
+    cd apps/{{ project }} && \
+    mix deps.get
+
 [doc('Run an arbitrary command inside the given project directory')]
 run project +ARGS:
     #!/usr/bin/env bash
@@ -34,10 +42,10 @@ mix project="all" *args="":
         for proj in {{ apps }}; do
           case $proj in
             expert)
-              (cd "apps/$proj" && elixir --erl "-start_epmd false -epmd_module Elixir.Forge.EPMD" -S mix {{args}})
+              (cd "apps/$proj" && elixir --erl "{{ expert_erl_flags }}" -S mix {{args}})
             ;;
             engine)
-              (cd "apps/$proj" && elixir --erl "-start_epmd false -epmd_module Elixir.Forge.EPMD" -S mix {{args}})
+              (cd "apps/$proj" && elixir --erl "{{ engine_erl_flags }}" -S mix {{args}})
             ;;
             *)
               (cd "apps/$proj" && mix {{args}})
@@ -46,10 +54,10 @@ mix project="all" *args="":
         done
       ;;
       expert)
-        (cd "apps/expert" && elixir --erl "-start_epmd false -epmd_module Elixir.Forge.EPMD" -S mix {{args}})
+        (cd "apps/expert" && elixir --erl "{{ expert_erl_flags }}" -S mix {{args}})
       ;;
       engine)
-        (cd "apps/engine" && elixir --erl "-start_epmd false -epmd_module Elixir.Forge.EPMD" -S mix {{args}})
+        (cd "apps/engine" && elixir --erl "{{ engine_erl_flags }}" -S mix {{args}})
       ;;
       *)
         (cd "apps/{{ project }}" && mix {{args}})
@@ -81,8 +89,11 @@ release-local: (deps "engine") (deps "expert")
 
 [windows]
 release-local: (deps "engine") (deps "expert")
-    # idk actually how to set env vars like this on windows, might crash
-    EXPERT_RELEASE_MODE=burrito BURRITO_TARGET="windows_amd64" MIX_ENV={{ env('MIX_ENV', 'prod')}} mix release --overwrite
+    export EXPERT_RELEASE_MODE=burrito && \
+    export BURRITO_TARGET="windows_amd64" && \
+    export MIX_ENV={{ env('MIX_ENV', 'prod')}} && \
+    cd apps/expert && \
+    mix release --overwrite
 
 [doc('Build releases for all target platforms')]
 release-all: (deps "engine") (deps "expert")