feat: add JULIA_EXE env var for custom Julia binary (#18)

* feat: add JULIA_EXE env var to specify Julia binary

* cleanup: remove juliaExe field from struct; trim skill docs

* fix: add missing logFile arg to test newJuliaSession calls

Author: Beforerr

README.md

@@ -31,6 +31,9 @@ Or manually by adding this repo's `skills/` directory to your Agent skill search
 # Evaluate code (daemon starts automatically)
 julia-client -e 'println("hello")'
 
+# Use a custom Julia binary via JULIA_EXE environment variable
+JULIA_EXE=/path/to/julia julia-client -e 'println("hello")'
+
 # Explicit project: each distinct --project is its own session
 julia-client --project /path/to/project -e 'using MyPackage'
 julia-client --project @temp -e 'using Pkg; Pkg.add("Example")'

go/daemon.go

@@ -166,7 +166,7 @@ func handleStreamingEval(state *daemonState, req protocolRequest, conn net.Conn)
 	if req.Fresh {
 		state.manager.restart(req.Session, req.Project, req.Cwd)
 	}
-	sess, err := state.manager.getOrCreate(req.Cwd, req.Project, req.Session, req.JuliaArgs)
+	sess, err := state.manager.getOrCreate(req.Cwd, req.Project, req.Session, req.JuliaExe, req.JuliaArgs)
 	if err != nil {
 		emit(streamFrame{Done: true, Error: err.Error()})
 		return

go/main.go

@@ -59,6 +59,7 @@ type protocolRequest struct {
 	Project     string   `json:"project,omitempty"`
 	Session     string   `json:"session,omitempty"`
 	JuliaArgs   []string `json:"julia_args,omitempty"` // extra switches forwarded to the julia subprocess
+	JuliaExe    string   `json:"julia_exe,omitempty"`  // custom Julia binary path
 	PrintResult bool     `json:"print_result,omitempty"`
 	Fresh       bool     `json:"fresh,omitempty"`
 	TraceLevel  string   `json:"trace_level,omitempty"`
@@ -146,7 +147,7 @@ func normalizeProjectArg(project string) string {
 	return projectArg
 }
 
-func cmdEval(socketPath, code, project, session string, printResult, fresh bool, traceLevel string, juliaArgs []string) {
+func cmdEval(socketPath, code, project, session, juliaExe string, printResult, fresh bool, traceLevel string, juliaArgs []string) {
 	if code == "-" {
 		b, err := io.ReadAll(os.Stdin)
 		if err != nil {
@@ -161,6 +162,7 @@ func cmdEval(socketPath, code, project, session string, printResult, fresh bool,
 		Cwd:         mustGetwd(),
 		Project:     normalizeProjectArg(project),
 		Session:     session,
+		JuliaExe:    juliaExe,
 		TraceLevel:  traceLevel,
 		JuliaArgs:   juliaArgs,
 		PrintResult: printResult,
@@ -249,6 +251,7 @@ var subcommands = map[string]bool{
 // passthrough switches for the Julia subprocess.
 type parsed struct {
 	socket    string
+	juliaExe  string
 	project   string
 	session   string
 	trace     string
@@ -270,16 +273,17 @@ type parsed struct {
 func parseArgs(args []string) parsed {
 	// Canonical name (dashes/value stripped) -> setter on p.
 	value := map[string]func(*parsed, string){
-		"e":       func(p *parsed, v string) { p.evalMode, p.code = "eval", v },
-		"eval":    func(p *parsed, v string) { p.evalMode, p.code = "eval", v },
-		"E":       func(p *parsed, v string) { p.evalMode, p.code = "print", v },
-		"print":   func(p *parsed, v string) { p.evalMode, p.code = "print", v },
-		"socket":  func(p *parsed, v string) { p.socket = v },
-		"project": func(p *parsed, v string) { p.project = v },
-		"session": func(p *parsed, v string) { p.session = v },
-		"trace":   func(p *parsed, v string) { p.trace = v },
-		"t":       func(p *parsed, v string) { p.threads = v },
-		"threads": func(p *parsed, v string) { p.threads = v },
+		"e":          func(p *parsed, v string) { p.evalMode, p.code = "eval", v },
+		"eval":       func(p *parsed, v string) { p.evalMode, p.code = "eval", v },
+		"E":          func(p *parsed, v string) { p.evalMode, p.code = "print", v },
+		"print":      func(p *parsed, v string) { p.evalMode, p.code = "print", v },
+		"socket":     func(p *parsed, v string) { p.socket = v },
+
+		"project":    func(p *parsed, v string) { p.project = v },
+		"session":    func(p *parsed, v string) { p.session = v },
+		"trace":      func(p *parsed, v string) { p.trace = v },
+		"t":          func(p *parsed, v string) { p.threads = v },
+		"threads":    func(p *parsed, v string) { p.threads = v },
 	}
 
 	p := parsed{socket: defaultSocket, project: "@."}
@@ -342,24 +346,27 @@ func main() {
 		juliaArgs = append(juliaArgs, "-t", t)
 	}
 
+	// JULIA_EXE selects the Julia binary; empty means look up "julia" in PATH.
+	juliaExe := os.Getenv("JULIA_EXE")
+
 	switch {
 	case p.evalMode != "":
-		cmdEval(p.socket, p.code, p.project, p.session, p.evalMode == "print", p.fresh, p.trace, juliaArgs)
+		cmdEval(p.socket, p.code, p.project, p.session, juliaExe, p.evalMode == "print", p.fresh, p.trace, juliaArgs)
 	case len(p.files) > 0:
 		f := p.files[0]
 		if _, err := os.Stat(f); err != nil {
 			fmt.Fprintf(os.Stderr, "unknown command: %s\n", f)
 			usage()
 		}
 		code := fmt.Sprintf("cd(%q) do; Base.include(Main, %q); end", mustGetwd(), f)
-		cmdEval(p.socket, code, p.project, p.session, false, p.fresh, p.trace, juliaArgs)
+		cmdEval(p.socket, code, p.project, p.session, juliaExe, false, p.fresh, p.trace, juliaArgs)
 	default:
 		// No code given: read stdin only if it's a pipe/redirect, not a terminal.
 		fi, err := os.Stdin.Stat()
 		if err != nil || fi.Mode()&os.ModeCharDevice != 0 {
 			usage()
 		}
-		cmdEval(p.socket, "-", p.project, p.session, false, p.fresh, p.trace, juliaArgs)
+		cmdEval(p.socket, "-", p.project, p.session, juliaExe, false, p.fresh, p.trace, juliaArgs)
 	}
 }
 

go/manager.go

@@ -56,7 +56,7 @@ func (m *SessionManager) openLogFile(key string) *os.File {
 
 // juliaArgs apply only when a session is first created; a live session for the
 // key is reused as-is regardless (use --fresh to rebuild with new args).
-func (m *SessionManager) getOrCreate(cwd, project, session string, juliaArgs []string) (*JuliaSession, error) {
+func (m *SessionManager) getOrCreate(cwd, project, session, juliaExe string, juliaArgs []string) (*JuliaSession, error) {
 	key := m.key(session, project, cwd)
 
 	// Fast path: return existing live session without singleflight overhead.
@@ -87,7 +87,7 @@ func (m *SessionManager) getOrCreate(cwd, project, session string, juliaArgs []s
 			projectVal = "@."
 		}
 		sess = newJuliaSession(projectVal, newSentinel(), juliaArgs, m.openLogFile(key))
-		if err := sess.start(cwd); err != nil {
+		if err := sess.start(juliaExe, cwd); err != nil {
 			return nil, err
 		}
 

go/session.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -55,10 +56,21 @@ func newJuliaSession(projectVal, sentinel string, juliaArgs []string, logFile *o
 	}
 }
 
-func (s *JuliaSession) start(workDir string) error {
-	exe, err := exec.LookPath("julia")
-	if err != nil {
-		return fmt.Errorf("'julia' not found in PATH. Install Julia from https://julialang.org/downloads/")
+func (s *JuliaSession) start(juliaExe string, workDir string) error {
+	var exe string
+	if juliaExe != "" {
+		if filepath.IsAbs(juliaExe) {
+			exe = juliaExe
+		} else {
+			// Relative path: resolved relative to the project directory
+			exe = filepath.Join(s.projectVal, juliaExe)
+		}
+	} else {
+		var err error
+		exe, err = exec.LookPath("julia")
+		if err != nil {
+			return fmt.Errorf("'julia' not found in PATH. Install Julia from https://julialang.org/downloads/")
+		}
 	}
 
 	// A juliaup channel (+x) must be Julia's very first argument; keep it there.

skills/julia-client/SKILL.md

@@ -15,6 +15,10 @@ Treat `julia-client` like persistent REPL: run setup once with `julia-client -E
   - struct/type redefinition
   - adding `using NewPkg` inside modules whose `Project.toml` didn't already list `NewPkg` dep (the module's load-time dep view is cached so `Pkg.add`+edit isn't enough)
 
+## Environment
+
+- `JULIA_EXE` — Path to the Julia binary. If unset, `julia` is looked up in `$PATH`.
+
 ## Other Examples
 
 ```bash