refactor: unify into single muyue binary with embedded desktop mode

- Merge muyue + muyue-desktop into one binary (13MB)
- `muyue` starts TUI, `muyue desktop` launches web UI in browser
- Move frontend from cmd/muyue-desktop/frontend/ to web/ (standard Go layout)
- Add web/embed.go with //go:embed all:dist for frontend assets
- Add internal/desktop/ package (server, browser open, SPA routing, signals)
- Split internal/api/api.go into server.go + handlers.go
- Add internal/desktop/desktop.go with SPA fallback and --port/--no-open flags
- Clean package.json: remove unused @xterm/xterm, switch to ESM
- Fix vite.config.js proxy to use port 8095 for dev mode
- Add Makefile targets: frontend, desktop, dev-desktop
- Update all CI workflows: single binary build, web/ paths
- Remove cmd/muyue-desktop/ entirely

💘 Generated with Crush

Assisted-by: GLM-5.1 via Crush <crush@charm.land>

internal/api/handlers.go

@@ -4,9 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"os/exec"
-	"strings"
 
-	"github.com/muyue/muyue/internal/config"
 	"github.com/muyue/muyue/internal/lsp"
 	"github.com/muyue/muyue/internal/mcp"
 	"github.com/muyue/muyue/internal/scanner"
@@ -15,50 +13,6 @@ import (
 	"github.com/muyue/muyue/internal/version"
 )
 
-type Server struct {
-	config     *config.MuyueConfig
-	scanResult *scanner.ScanResult
-	mux        *http.ServeMux
-}
-
-func NewServer(cfg *config.MuyueConfig) *Server {
-	s := &Server{
-		config: cfg,
-		mux:    http.NewServeMux(),
-	}
-	s.scanResult = scanner.ScanSystem()
-	s.routes()
-	return s
-}
-
-func (s *Server) routes() {
-	s.mux.HandleFunc("/api/info", s.handleInfo)
-	s.mux.HandleFunc("/api/system", s.handleSystem)
-	s.mux.HandleFunc("/api/tools", s.handleTools)
-	s.mux.HandleFunc("/api/config", s.handleConfig)
-	s.mux.HandleFunc("/api/providers", s.handleProviders)
-	s.mux.HandleFunc("/api/skills", s.handleSkills)
-	s.mux.HandleFunc("/api/lsp", s.handleLSP)
-	s.mux.HandleFunc("/api/mcp", s.handleMCP)
-	s.mux.HandleFunc("/api/updates", s.handleUpdates)
-	s.mux.HandleFunc("/api/install", s.handleInstall)
-	s.mux.HandleFunc("/api/scan", s.handleScan)
-	s.mux.HandleFunc("/api/terminal", s.handleTerminal)
-	s.mux.HandleFunc("/api/mcp/configure", s.handleMCPConfigure)
-}
-
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-	w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
-	if r.Method == "OPTIONS" {
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-	s.mux.ServeHTTP(w, r)
-}
-
 func writeJSON(w http.ResponseWriter, data interface{}) {
 	json.NewEncoder(w).Encode(data)
 }
@@ -85,20 +39,19 @@ func (s *Server) handleSystem(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-type ToolInfo struct {
-	Name      string `json:"name"`
-	Installed bool   `json:"installed"`
-	Version   string `json:"version"`
-	Path      string `json:"path"`
-}
-
 func (s *Server) handleTools(w http.ResponseWriter, r *http.Request) {
 	if s.scanResult == nil {
 		s.scanResult = scanner.ScanSystem()
 	}
-	tools := make([]ToolInfo, len(s.scanResult.Tools))
+	type toolInfo struct {
+		Name      string `json:"name"`
+		Installed bool   `json:"installed"`
+		Version   string `json:"version"`
+		Path      string `json:"path"`
+	}
+	tools := make([]toolInfo, len(s.scanResult.Tools))
 	for i, t := range s.scanResult.Tools {
-		tools[i] = ToolInfo{
+		tools[i] = toolInfo{
 			Name:      t.Name,
 			Installed: t.Installed,
 			Version:   t.Version,
@@ -117,9 +70,9 @@ func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	writeJSON(w, map[string]interface{}{
-		"profile":   s.config.Profile,
-		"terminal":  s.config.Terminal,
-		"bmad":      s.config.BMAD,
+		"profile":  s.config.Profile,
+		"terminal": s.config.Terminal,
+		"bmad":     s.config.BMAD,
 	})
 }
 
@@ -155,7 +108,7 @@ func (s *Server) handleLSP(w http.ResponseWriter, r *http.Request) {
 func (s *Server) handleMCP(w http.ResponseWriter, r *http.Request) {
 	servers := mcp.ScanServers()
 	writeJSON(w, map[string]interface{}{
-		"servers":   servers,
+		"servers":    servers,
 		"configured": true,
 	})
 }
@@ -165,8 +118,7 @@ func (s *Server) handleMCPConfigure(w http.ResponseWriter, r *http.Request) {
 		writeError(w, "POST only", http.StatusMethodNotAllowed)
 		return
 	}
-	err := mcp.ConfigureAll(s.config)
-	if err != nil {
+	if err := mcp.ConfigureAll(s.config); err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -222,11 +174,6 @@ func (s *Server) handleScan(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, map[string]string{"status": "ok"})
 }
 
-type TermResult struct {
-	Output string `json:"output"`
-	Error  string `json:"error,omitempty"`
-}
-
 func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
 		writeError(w, "POST only", http.StatusMethodNotAllowed)
@@ -240,17 +187,14 @@ func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-
 	if body.Command == "" {
 		writeError(w, "no command", http.StatusBadRequest)
 		return
 	}
 
 	shell := "/bin/sh"
-	if sh := strings.TrimSpace(body.Command); sh != "" {
-		if s, err := exec.LookPath("bash"); err == nil {
-			shell = s
-		}
+	if s, err := exec.LookPath("bash"); err == nil {
+		shell = s
 	}
 
 	cmd := exec.Command(shell, "-c", body.Command)
@@ -258,7 +202,12 @@ func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
 		cmd.Dir = body.Cwd
 	}
 	out, err := cmd.CombinedOutput()
-	result := TermResult{Output: string(out)}
+
+	type termResult struct {
+		Output string `json:"output"`
+		Error  string `json:"error,omitempty"`
+	}
+	result := termResult{Output: string(out)}
 	if err != nil {
 		result.Error = err.Error()
 	}

internal/api/server.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/muyue/muyue/internal/config"
+	"github.com/muyue/muyue/internal/scanner"
+)
+
+type Server struct {
+	config     *config.MuyueConfig
+	scanResult *scanner.ScanResult
+	mux        *http.ServeMux
+}
+
+func NewServer(cfg *config.MuyueConfig) *Server {
+	s := &Server{
+		config: cfg,
+		mux:    http.NewServeMux(),
+	}
+	s.scanResult = scanner.ScanSystem()
+	s.routes()
+	return s
+}
+
+func (s *Server) routes() {
+	s.mux.HandleFunc("/api/info", s.handleInfo)
+	s.mux.HandleFunc("/api/system", s.handleSystem)
+	s.mux.HandleFunc("/api/tools", s.handleTools)
+	s.mux.HandleFunc("/api/config", s.handleConfig)
+	s.mux.HandleFunc("/api/providers", s.handleProviders)
+	s.mux.HandleFunc("/api/skills", s.handleSkills)
+	s.mux.HandleFunc("/api/lsp", s.handleLSP)
+	s.mux.HandleFunc("/api/mcp", s.handleMCP)
+	s.mux.HandleFunc("/api/updates", s.handleUpdates)
+	s.mux.HandleFunc("/api/install", s.handleInstall)
+	s.mux.HandleFunc("/api/scan", s.handleScan)
+	s.mux.HandleFunc("/api/terminal", s.handleTerminal)
+	s.mux.HandleFunc("/api/mcp/configure", s.handleMCPConfigure)
+}
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+	if r.Method == "OPTIONS" {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	s.mux.ServeHTTP(w, r)
+}

internal/desktop/desktop.go

@@ -0,0 +1,131 @@
+package desktop
+
+import (
+	"fmt"
+	"io/fs"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/muyue/muyue/internal/api"
+	"github.com/muyue/muyue/internal/config"
+	"github.com/muyue/muyue/internal/version"
+	"github.com/muyue/muyue/web"
+)
+
+type options struct {
+	port   int
+	noOpen bool
+}
+
+type option func(*options)
+
+func WithPort(port int) option {
+	return func(o *options) { o.port = port }
+}
+
+func WithNoOpen(noOpen bool) option {
+	return func(o *options) { o.noOpen = noOpen }
+}
+
+func parseFlags(args []string) []option {
+	var opts []option
+	for _, arg := range args {
+		switch {
+		case arg == "--no-open":
+			opts = append(opts, WithNoOpen(true))
+		case strings.HasPrefix(arg, "--port="):
+			if p, err := strconv.Atoi(strings.TrimPrefix(arg, "--port=")); err == nil {
+				opts = append(opts, WithPort(p))
+			}
+		case arg == "--port":
+			// handled as prefix case
+		}
+	}
+	return opts
+}
+
+func Run(cfg *config.MuyueConfig, args []string) error {
+	o := options{}
+	for _, opt := range parseFlags(args) {
+		opt(&o)
+	}
+
+	log.Printf("%s Desktop v%s", version.Name, version.Version)
+
+	srv := api.NewServer(cfg)
+
+	frontendFS, err := fs.Sub(web.Assets, "dist")
+	if err != nil {
+		return fmt.Errorf("frontend assets: %w", err)
+	}
+
+	mux := http.NewServeMux()
+	mux.Handle("/api/", srv)
+	mux.Handle("/", spaHandler(http.FileServer(http.FS(frontendFS))))
+
+	addr := fmt.Sprintf("127.0.0.1:%d", o.port)
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return fmt.Errorf("bind %s: %w", addr, err)
+	}
+	port := listener.Addr().(*net.TCPAddr).Port
+
+	go func() {
+		if err := http.Serve(listener, mux); err != nil {
+			log.Fatalf("Server error: %v", err)
+		}
+	}()
+
+	url := fmt.Sprintf("http://127.0.0.1:%d", port)
+	log.Printf("Listening on %s", url)
+
+	if !o.noOpen {
+		openBrowser(url)
+		log.Printf("Opened browser")
+	}
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	log.Println("Shutting down...")
+	return nil
+}
+
+func spaHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+		if path != "/" && !strings.Contains(path, ".") {
+			r.URL.Path = "/"
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+func openBrowser(url string) {
+	var cmd *exec.Cmd
+	switch {
+	case exists("xdg-open"):
+		cmd = exec.Command("xdg-open", url)
+	case exists("open"):
+		cmd = exec.Command("open", url)
+	case exists("cmd"):
+		cmd = exec.Command("cmd", "/c", "start", url)
+	default:
+		fmt.Printf("Open manually: %s\n", url)
+		return
+	}
+	_ = cmd.Start()
+}
+
+func exists(name string) bool {
+	_, err := exec.LookPath(name)
+	return err == nil
+}