magic-agent 1.0.3 → 1.0.49

package/internal/client/daemon.go

@@ -0,0 +1,525 @@
+package client
+
+/* 后台常驻（`magic-client start|stop|status`）的落地层。
+ *
+ * ── 为什么需要这一层 ──
+ * 手机的连接入口是「一个还在跑的 serve 进程 + 它的端口 + 令牌」。手工 `serve --lan`
+ * 是**前台**进程：关掉终端就没了；而端口是 0（系统分配），下次启动又是另一个端口 ——
+ * 用户既记不住，也没法把它抄进手机。所以这里把
+ * 「pid + 端口 + 令牌 + 局域网地址」落成一份 0600 的状态文件，
+ * start / status / stop 三个动作围绕同一份事实工作，谁也不再猜。
+ *
+ * ── 为什么由 serve 自己写 ready 文件，而不是父进程猜端口 ──
+ * 端口在 bind 之后才知道（`net.Listen("tcp","0.0.0.0:0")`），父进程只能事后读日志正则 ——
+ * 那是最脆的一种解析（日志格式一改就断）。所以让 serve 在监听成功后**原子写**一份 JSON，
+ * 父进程只等这个文件出现。
+ *
+ * ── 幂等 ──
+ * start 发现已有实例活着就**不再起第二个**：第二个会占另一个端口，而手机扫到的还是旧地址，
+ * 用户看到的现象是「启动了但连不上」。stop 同理：本来没跑也算成功（脚本可以直接调）。
+ */
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+const (
+	// EnvState 覆盖状态文件位置（多实例 / 测试用）。
+	EnvState = "MAGIC_CLIENT_STATE"
+	// EnvLog 覆盖后台日志文件位置。
+	EnvLog = "MAGIC_CLIENT_LOG"
+)
+
+const (
+	// defaultReadyWait 等 serve 报端口的时长。第一次启动要跑 `--contract` 探测引擎，
+	// 慢机器上 3~5s 很常见，给到 15s 留余量。
+	defaultReadyWait = 15 * time.Second
+	// stopGrace SIGTERM 之后等它自己收尾的时长，超时才 SIGKILL。
+	stopGrace = 5 * time.Second
+	// probeTimeout 单次探活超时：这是本机请求，慢成这样已经算挂了。
+	probeTimeout = 1500 * time.Millisecond
+)
+
+// DefaultStatePath 状态文件默认位置：~/.magic-client/client.json。
+func DefaultStatePath() string {
+	if p := strings.TrimSpace(os.Getenv(EnvState)); p != "" {
+		return expandHome(p)
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return filepath.Join(os.TempDir(), "magic-client", "client.json")
+	}
+	return filepath.Join(home, ".magic-client", "client.json")
+}
+
+// DefaultLogPath 后台日志默认位置：~/.magic-client/logs/client.log。
+//
+// 必须有日志：detach 之后 stderr 没人接，启动失败的原因（契约不匹配、端口占用、
+// ui 目录不存在）就彻底消失了，只剩一句「没起来」。
+func DefaultLogPath() string {
+	if p := strings.TrimSpace(os.Getenv(EnvLog)); p != "" {
+		return expandHome(p)
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return filepath.Join(os.TempDir(), "magic-client", "client.log")
+	}
+	return filepath.Join(home, ".magic-client", "logs", "client.log")
+}
+
+// NewToken 生成访问令牌（16 字节 = 32 个十六进制字符，远强于局域网那条 24 字符下限）。
+func NewToken() string {
+	b := make([]byte, 16)
+	if _, err := rand.Read(b); err != nil {
+		return fmt.Sprintf("%d", time.Now().UnixNano())
+	}
+	return hex.EncodeToString(b)
+}
+
+// ReadyInfo serve 监听成功后报给父进程的事实。
+type ReadyInfo struct {
+	PID       int      `json:"pid"`
+	Port      int      `json:"port"`
+	Addr      string   `json:"addr"`
+	URL       string   `json:"url"`
+	Lan       bool     `json:"lan"`
+	LanAddrs  []string `json:"lanAddrs,omitempty"`
+	ProxyAddr string   `json:"proxyAddr,omitempty"`
+}
+
+// WriteReadyFile 原子写 ready 文件（临时文件 + rename）：
+// 父进程按「文件出现」判断就绪，半截 JSON 会让它白等一轮。
+func WriteReadyFile(path string, info ReadyInfo) error {
+	if strings.TrimSpace(path) == "" {
+		return nil
+	}
+	if info.PID == 0 {
+		info.PID = os.Getpid()
+	}
+	data, err := json.Marshal(info)
+	if err != nil {
+		return err
+	}
+	if dir := filepath.Dir(path); dir != "" && dir != "." {
+		if err := os.MkdirAll(dir, 0o700); err != nil {
+			return err
+		}
+	}
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0o600); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+// readReadyFile 读 ready 文件：不存在就返回 (nil, nil)（父进程轮询用）。
+func readReadyFile(path string) (*ReadyInfo, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	if len(data) == 0 {
+		return nil, nil
+	}
+	var info ReadyInfo
+	if err := json.Unmarshal(data, &info); err != nil {
+		return nil, err
+	}
+	if info.Port == 0 {
+		return nil, nil
+	}
+	return &info, nil
+}
+
+// DaemonState 一份还在跑（或刚停掉）的实例的完整事实。
+//
+// ⚠️ 里面有令牌 → 文件权限恒 0600。这不是「多一层保险」，是唯一的门锁：
+// 能读到这个文件的人本来就能连上服务。
+type DaemonState struct {
+	PID       int       `json:"pid"`
+	Port      int       `json:"port"`
+	URL       string    `json:"url"`      // 本机地址（含令牌）
+	LanAddrs  []string  `json:"lanAddrs"` // 手机可用地址（含令牌）；空 = 只绑了回环
+	Lan       bool      `json:"lan"`
+	Profile   string    `json:"profile,omitempty"`
+	UIRoot    string    `json:"uiDir,omitempty"`
+	MobileDir string    `json:"mobileDir,omitempty"`
+	ProxyAddr string    `json:"proxyAddr,omitempty"`
+	Token     string    `json:"token"`
+	StartedAt time.Time `json:"startedAt"`
+	LogPath   string    `json:"logPath"`
+	StatePath string    `json:"statePath"`
+	Exe       string    `json:"exe"`
+}
+
+// Base 本机根地址（不带令牌）。
+func (s *DaemonState) Base() string {
+	if s == nil || s.Port == 0 {
+		return ""
+	}
+	return fmt.Sprintf("http://127.0.0.1:%d", s.Port)
+}
+
+// writeDaemonState 落盘（0600，原子）。
+func writeDaemonState(path string, st *DaemonState) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(st, "", "  ")
+	if err != nil {
+		return err
+	}
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, 0o600); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+// ReadDaemonState 读状态文件：不存在 → (nil, nil)。
+func ReadDaemonState(path string) (*DaemonState, error) {
+	if strings.TrimSpace(path) == "" {
+		path = DefaultStatePath()
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	var st DaemonState
+	if err := json.Unmarshal(data, &st); err != nil {
+		return nil, fmt.Errorf("状态文件 %s 解析失败（删掉它再 start 即可）：%w", path, err)
+	}
+	st.StatePath = path
+	return &st, nil
+}
+
+// Health `/desk/health` 的响应（只取我们关心的字段）。
+type Health struct {
+	OK               bool   `json:"ok"`
+	App              string `json:"app"`
+	ContractVersion  int    `json:"contractVersion"`
+	Engines          int    `json:"engines"`
+	DefaultWorkspace string `json:"defaultWorkspace"`
+}
+
+// probeHealth 探活：本机回环 + 令牌。
+//
+// 为什么走 /desk/health 而不是只看 pid：pid 会被复用，而且「进程在、服务不可用」
+// （绑定失败后卡住、core 契约不匹配）也是常见形态。能答上来才算真的能用。
+func probeHealth(port int, token string) (*Health, error) {
+	if port <= 0 {
+		return nil, fmt.Errorf("端口无效")
+	}
+	url := fmt.Sprintf("http://127.0.0.1:%d/desk/health", port)
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+	if token != "" {
+		req.Header.Set("X-Magic-Token", token)
+	}
+	cli := &http.Client{Timeout: probeTimeout}
+	resp, err := cli.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("健康检查返回 %d", resp.StatusCode)
+	}
+	var h Health
+	if err := json.NewDecoder(resp.Body).Decode(&h); err != nil {
+		return nil, err
+	}
+	return &h, nil
+}
+
+// TokenPath 令牌文件：与状态文件同目录的 token。
+//
+// 为什么要单独一份、且 stop 时不删：状态文件随进程生命周期来去，令牌却必须**跨重启稳定** ——
+// 手机里存的是「地址 + 令牌」，每次 start 都换一个的话，用户的配对就白做了
+// （现象是「电脑重启后手机又说令牌不对」）。显式传 --token 时不写这份文件。
+func TokenPath(statePath string) string {
+	if strings.TrimSpace(statePath) == "" {
+		statePath = DefaultStatePath()
+	}
+	return filepath.Join(filepath.Dir(expandHome(statePath)), "token")
+}
+
+// resolveToken 取令牌：显式值 > 已存令牌 > 新生成（并落盘）。
+func resolveToken(statePath, explicit string) string {
+	if t := strings.TrimSpace(explicit); t != "" {
+		return t
+	}
+	p := TokenPath(statePath)
+	if data, err := os.ReadFile(p); err == nil {
+		if t := strings.TrimSpace(string(data)); len(t) >= MinLanTokenLen {
+			return t
+		}
+	}
+	t := NewToken()
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err == nil {
+		if werr := os.WriteFile(p, []byte(t+"\n"), 0o600); werr != nil {
+			// 存不下不是致命错误：本次仍能用，只是下次 start 会换个令牌。
+			fmt.Fprintf(os.Stderr, "magic-client: 警告 - 令牌没能存到 %s（%v），下次 start 会换新令牌\n", p, werr)
+		}
+	}
+	return t
+}
+
+// StartOptions `start` 的参数。
+type StartOptions struct {
+	// Exe 要拉起的可执行文件；空 = 当前进程自己（`magic-client start` 就是 magic-client）。
+	Exe string
+	// MagicAgent 交给 serve 的 core 路径；空 = 让它从 PATH 找。
+	// 由 CLI 侧填**当前进程自己**：PATH 里那份可能是旧版本，契约一比对就失败。
+	MagicAgent string
+
+	Profile   string
+	UIRoot    string
+	MobileDir string
+	Addr      string
+	Token     string
+	ProxyAddr string
+	BrowseUA  string
+	Lan       bool
+	StatePath string
+	LogPath   string
+	Wait      time.Duration
+}
+
+// StartDaemon 后台拉起一个 serve 进程，等它报端口，落状态文件。
+func StartDaemon(o StartOptions) (*DaemonState, error) {
+	exe := strings.TrimSpace(o.Exe)
+	if exe == "" {
+		p, err := os.Executable()
+		if err != nil {
+			return nil, fmt.Errorf("定位自身可执行文件失败：%w", err)
+		}
+		exe = p
+	}
+	statePath := strings.TrimSpace(o.StatePath)
+	if statePath == "" {
+		statePath = DefaultStatePath()
+	}
+	logPath := strings.TrimSpace(o.LogPath)
+	if logPath == "" {
+		logPath = DefaultLogPath()
+	}
+	statePath = expandHome(statePath)
+	logPath = expandHome(logPath)
+	wait := o.Wait
+	if wait <= 0 {
+		wait = defaultReadyWait
+	}
+
+	tok := strings.TrimSpace(o.Token)
+	if tok == "" {
+		tok = resolveToken(statePath, "")
+	}
+	if o.Lan {
+		if err := ValidateLanToken(tok); err != nil {
+			return nil, err
+		}
+	}
+
+	// 幂等：已有实例活着就直接返回，不再起第二个。
+	prev, err := ReadDaemonState(statePath)
+	if err != nil {
+		return nil, err
+	}
+	if prev != nil {
+		if h, herr := probeHealth(prev.Port, prev.Token); herr == nil && h.OK {
+			return prev, nil
+		}
+		// 进程不在了 / 答不上来：清掉陈旧状态，当成全新启动。
+		_ = os.Remove(statePath)
+	}
+
+	for _, d := range []string{filepath.Dir(statePath), filepath.Dir(logPath)} {
+		if err := os.MkdirAll(d, 0o700); err != nil {
+			return nil, fmt.Errorf("建目录 %s 失败：%w", d, err)
+		}
+	}
+	readyPath := statePath + ".ready"
+	_ = os.Remove(readyPath)
+
+	logf, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
+	if err != nil {
+		return nil, fmt.Errorf("打开日志文件 %s 失败：%w", logPath, err)
+	}
+	defer logf.Close()
+
+	args := []string{"serve", "--ready-file", readyPath, "--token", tok}
+	appendIf := func(flag, v string) {
+		if v = strings.TrimSpace(v); v != "" {
+			args = append(args, flag, v)
+		}
+	}
+	appendIf("--profile", o.Profile)
+	appendIf("--ui-dir", o.UIRoot)
+	appendIf("--mobile-dir", o.MobileDir)
+	appendIf("--addr", o.Addr)
+	appendIf("--proxy-addr", o.ProxyAddr)
+	appendIf("--browse-ua", o.BrowseUA)
+	appendIf("--magic-agent", o.MagicAgent)
+	if o.Lan {
+		args = append(args, "--lan")
+	}
+
+	cmd := exec.Command(exe, args...)
+	// cwd 沿用调用方：core 不传 -w 时默认工作空间就是 cwd（/desk/health 会报给客户端）。
+	if wd, werr := os.Getwd(); werr == nil {
+		cmd.Dir = wd
+	}
+	cmd.Stdout = logf
+	cmd.Stderr = logf
+	detach(cmd) // 脱离终端：关掉启动它的窗口后服务照旧活着
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("启动后台服务失败：%w", err)
+	}
+
+	exited := make(chan error, 1)
+	go func() { exited <- cmd.Wait() }()
+
+	var info *ReadyInfo
+	deadline := time.Now().Add(wait)
+	for info == nil {
+		select {
+		case werr := <-exited:
+			_ = os.Remove(readyPath)
+			return nil, fmt.Errorf("后台服务启动即退出（%v），日志见 %s", werr, logPath)
+		case <-time.After(50 * time.Millisecond):
+		}
+		ri, rerr := readReadyFile(readyPath)
+		if rerr == nil && ri != nil {
+			info = ri
+			break
+		}
+		if time.Now().After(deadline) {
+			_ = agent.TerminatePID(cmd.Process.Pid, false)
+			_ = os.Remove(readyPath)
+			return nil, fmt.Errorf("等了 %s 仍未拿到监听端口，日志见 %s", wait, logPath)
+		}
+	}
+	_ = os.Remove(readyPath)
+
+	st := &DaemonState{
+		PID:       info.PID,
+		Port:      info.Port,
+		URL:       info.URL,
+		LanAddrs:  info.LanAddrs,
+		Lan:       info.Lan,
+		Profile:   o.Profile,
+		UIRoot:    o.UIRoot,
+		MobileDir: o.MobileDir,
+		ProxyAddr: info.ProxyAddr,
+		Token:     tok,
+		StartedAt: time.Now(),
+		LogPath:   logPath,
+		StatePath: statePath,
+		Exe:       exe,
+	}
+	if st.PID == 0 {
+		st.PID = cmd.Process.Pid
+	}
+	if err := writeDaemonState(statePath, st); err != nil {
+		return nil, err
+	}
+	return st, nil
+}
+
+// StopOptions `stop` 的参数。
+type StopOptions struct {
+	StatePath string
+}
+
+// StopDaemon 停掉后台实例。
+//
+// 返回 stopped 表示「这次真的停了它」；本来没跑 → (false, nil, nil)，退出码仍是 0
+// （脚本里 `stop` 后接 `start` 不该因为「本来就没跑」而失败）。
+func StopDaemon(o StopOptions) (bool, *DaemonState, error) {
+	statePath := strings.TrimSpace(o.StatePath)
+	if statePath == "" {
+		statePath = DefaultStatePath()
+	}
+	st, err := ReadDaemonState(statePath)
+	if err != nil {
+		return false, nil, err
+	}
+	if st == nil {
+		return false, nil, nil
+	}
+	if !agent.PIDAlive(st.PID) {
+		_ = os.Remove(statePath)
+		return false, st, nil
+	}
+	// SIGTERM 先礼：serve 收到后会 srv.Close()，正在跑的请求有机会收尾。
+	_ = agent.TerminatePID(st.PID, false)
+	deadline := time.Now().Add(stopGrace)
+	for time.Now().Before(deadline) {
+		if !agent.PIDAlive(st.PID) {
+			_ = os.Remove(statePath)
+			return true, st, nil
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	_ = agent.KillPID(st.PID, false)
+	_ = os.Remove(statePath)
+	return true, st, nil
+}
+
+// DaemonStatus 一份对外可读的运行状态（给 `status` 与排障用）。
+type DaemonStatus struct {
+	Running bool         `json:"running"`
+	State   *DaemonState `json:"state,omitempty"`
+	Health  *Health      `json:"health,omitempty"`
+	Note    string       `json:"note,omitempty"`
+}
+
+// StatusDaemon 读状态并探活。
+//
+// 判据是「pid 活着 **且** 能答上 /desk/health」：只有 pid 活着但服务不可用时，
+// 报 running 会让人以为能用，实际手机连不上。
+func StatusDaemon(statePath string) (*DaemonStatus, error) {
+	if strings.TrimSpace(statePath) == "" {
+		statePath = DefaultStatePath()
+	}
+	st, err := ReadDaemonState(statePath)
+	if err != nil {
+		return nil, err
+	}
+	if st == nil {
+		return &DaemonStatus{Running: false, Note: "没有状态文件：从未 start，或已 stop"}, nil
+	}
+	out := &DaemonStatus{State: st}
+	if !agent.PIDAlive(st.PID) {
+		out.Note = "进程已不在（pid " + fmt.Sprint(st.PID) + " 无响应）"
+		return out, nil
+	}
+	h, herr := probeHealth(st.Port, st.Token)
+	if herr != nil {
+		out.Note = "进程在，但健康检查失败：" + herr.Error()
+		return out, nil
+	}
+	out.Running = true
+	out.Health = h
+	return out, nil
+}