install.go

package main

import (
	"bytes"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"time"
)

const launchLabel = "dev.mmux"

// launchd hands a service a bare PATH, and MCP servers are usually launched through
// `npx`, which commonly lives in a version-manager shim directory. Baking the PATH of
// the shell that ran `install` into the plist is what keeps the backends findable —
// without it mmux starts fine and every backend dies with "executable file not found".
func buildPlist(binary, cfgPath, pathEnv, home, logPath string) []byte {
	var b bytes.Buffer
	esc := func(s string) string {
		var e bytes.Buffer
		_ = xml.EscapeText(&e, []byte(s))
		return e.String()
	}
	fmt.Fprint(&b, xml.Header)
	fmt.Fprint(&b, "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n")
	fmt.Fprint(&b, "<plist version=\"1.0\">\n<dict>\n")
	fmt.Fprintf(&b, "  <key>Label</key><string>%s</string>\n", esc(launchLabel))
	fmt.Fprint(&b, "  <key>ProgramArguments</key>\n  <array>\n")
	for _, a := range []string{binary, "-config", cfgPath} {
		fmt.Fprintf(&b, "    <string>%s</string>\n", esc(a))
	}
	fmt.Fprint(&b, "  </array>\n")
	fmt.Fprint(&b, "  <key>RunAtLoad</key><true/>\n")
	fmt.Fprint(&b, "  <key>KeepAlive</key><true/>\n")
	fmt.Fprint(&b, "  <key>ProcessType</key><string>Background</string>\n")
	fmt.Fprint(&b, "  <key>EnvironmentVariables</key>\n  <dict>\n")
	fmt.Fprintf(&b, "    <key>PATH</key><string>%s</string>\n", esc(pathEnv))
	fmt.Fprintf(&b, "    <key>HOME</key><string>%s</string>\n", esc(home))
	fmt.Fprint(&b, "  </dict>\n")
	fmt.Fprintf(&b, "  <key>StandardOutPath</key><string>%s</string>\n", esc(logPath))
	fmt.Fprintf(&b, "  <key>StandardErrorPath</key><string>%s</string>\n", esc(logPath))
	fmt.Fprint(&b, "</dict>\n</plist>\n")
	return b.Bytes()
}

func plistDest(home string) string {
	return filepath.Join(home, "Library", "LaunchAgents", launchLabel+".plist")
}

func requireDarwin(action string) error {
	if runtime.GOOS != "darwin" {
		return fmt.Errorf("%s manages a launchd agent and only works on macOS (this is %s); "+
			"on Linux write a systemd --user unit that runs %q", action, runtime.GOOS, "mmux -config <path>")
	}
	return nil
}

func runInstall(cfgPath string) error {
	if err := requireDarwin("install"); err != nil {
		return err
	}

	// Fail before touching launchd if the config is missing or unparseable — a service
	// that crash-loops on a bad config is worse than a refused install.
	cfg, err := loadConfig(cfgPath)
	if err != nil {
		return fmt.Errorf("config: %w", err)
	}
	absCfg, err := filepath.Abs(cfgPath)
	if err != nil {
		return err
	}

	exe, err := os.Executable()
	if err != nil {
		return err
	}
	// Resolve symlinks so the agent keeps working if a PATH symlink is later removed.
	if resolved, err := filepath.EvalSymlinks(exe); err == nil {
		exe = resolved
	}

	home, err := os.UserHomeDir()
	if err != nil {
		return err
	}
	logPath := filepath.Join(home, "Library", "Logs", "mmux.log")
	dest := plistDest(home)

	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
		return err
	}
	if err := os.MkdirAll(filepath.Dir(logPath), 0o755); err != nil {
		return err
	}
	if err := os.WriteFile(dest, buildPlist(exe, absCfg, os.Getenv("PATH"), home, logPath), 0o644); err != nil {
		return err
	}

	// Idempotent: a stale agent must go before the new plist can take effect.
	_ = exec.Command("launchctl", "unload", dest).Run()
	if out, err := exec.Command("launchctl", "load", dest).CombinedOutput(); err != nil {
		return fmt.Errorf("launchctl load: %w: %s", err, bytes.TrimSpace(out))
	}

	fmt.Println("installed:", dest)
	fmt.Println("binary:   ", exe)
	fmt.Println("config:   ", absCfg)
	fmt.Println("log:      ", logPath)
	return waitHealthy(cfg)
}

func runUninstall() error {
	if err := requireDarwin("uninstall"); err != nil {
		return err
	}
	home, err := os.UserHomeDir()
	if err != nil {
		return err
	}
	dest := plistDest(home)
	if _, err := os.Stat(dest); os.IsNotExist(err) {
		fmt.Println("not installed:", dest)
		return nil
	}
	if out, err := exec.Command("launchctl", "unload", dest).CombinedOutput(); err != nil {
		return fmt.Errorf("launchctl unload: %w: %s", err, bytes.TrimSpace(out))
	}
	if err := os.Remove(dest); err != nil {
		return err
	}
	fmt.Println("uninstalled:", dest)
	return nil
}

// waitHealthy polls /status until every backend reports up, so `install` fails loudly
// rather than leaving a half-working agent behind.
func waitHealthy(cfg *config) error {
	url := "http://" + cfg.Listen + "/status"
	deadline := time.Now().Add(60 * time.Second)
	client := &http.Client{Timeout: 3 * time.Second}

	for time.Now().Before(deadline) {
		time.Sleep(time.Second)
		res, err := client.Get(url)
		if err != nil {
			continue
		}
		var st struct {
			Servers map[string]struct {
				Up  bool `json:"up"`
				PID int  `json:"pid"`
			} `json:"servers"`
		}
		err = json.NewDecoder(res.Body).Decode(&st)
		res.Body.Close()
		if err != nil || len(st.Servers) == 0 {
			continue
		}
		allUp := true
		for _, s := range st.Servers {
			if !s.Up {
				allUp = false
			}
		}
		if allUp {
			for name, s := range st.Servers {
				fmt.Printf("  %-16s up   pid=%d   http://%s/%s/mcp\n", name, s.PID, cfg.Listen, name)
			}
			return nil
		}
	}
	return fmt.Errorf("agent loaded but backends did not come up within 60s; check the log")
}