magic-agent 2.3.2 → 2.4.2

package/internal/session/workspace_lock.go

@@ -0,0 +1,165 @@
+package session
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+/* ── 工作空间串行锁（2026-10-23，多客户端串行的一部分）──
+
+为什么要锁在 core 而不是只靠 magic-client 的调度器：
+  · 同一台桌面上，除了 magic-client 起的轮次，还有人直接跑 `magic-agent -p`；
+  · 多台手机连的是同一个 magic-client，但**进程间**（多个 magic-client 实例）也可能并存。
+调度器只能管自己进程里的队列；一个落在文件系统上的锁才能让「谁先跑」对所有进程一致。
+
+为什么是选入式（MAGIC_AGENT_WORKSPACE_LOCK=1）：
+  默认开启会改变 CLI 的既有语义（两条命令并发跑本来是允许的），也会让团队模式的
+  子任务与主任务互相等待。这里只在 magic-client spawn core 时注入该环境变量，
+  团队子任务（ParentRunID 非空）自动跳过。
+
+锁的形态：<sessions dir>/locks/<sha1(workspace)>.lock，内容 `<pid>\n<unix nano>`。
+  · 用 O_CREATE|O_EXCL 原子创建；
+  · 持锁进程已不在 / 文件超过 staleAfter → 视为陈旧并回收；
+  · 进程退出没来得及删也不会永久堵住（下一步的持有者会按 pid 判死回收）。
+*/
+
+// EnvWorkspaceLock 打开「工作空间串行锁」的环境变量（值为 "1" 时生效）。
+const EnvWorkspaceLock = "MAGIC_AGENT_WORKSPACE_LOCK"
+
+// EnvWorkspaceLockWait 等锁上限（Go duration；默认 10m）。
+const EnvWorkspaceLockWait = "MAGIC_AGENT_WORKSPACE_LOCK_WAIT"
+
+const (
+	workspaceLockPoll  = 500 * time.Millisecond
+	workspaceLockStale = 6 * time.Hour
+)
+
+// WorkspaceLock 一把已持有的工作空间锁；Release 幂等。
+type WorkspaceLock struct {
+	path string
+	held bool
+}
+
+func workspaceLockEnabled() bool {
+	return strings.TrimSpace(os.Getenv(EnvWorkspaceLock)) == "1"
+}
+
+func workspaceLockWait() time.Duration {
+	if v := strings.TrimSpace(os.Getenv(EnvWorkspaceLockWait)); v != "" {
+		if d, err := time.ParseDuration(v); err == nil && d > 0 {
+			return d
+		}
+	}
+	return 10 * time.Minute
+}
+
+// lockKey 归一工作空间：空 = 进程 cwd；返回绝对路径 + 哈希文件名。
+func workspaceLockKey(workspace string) (key, file string) {
+	ws := strings.TrimSpace(workspace)
+	if ws == "" {
+		ws, _ = os.Getwd()
+	}
+	if abs, err := filepath.Abs(ws); err == nil {
+		ws = abs
+	}
+	ws = filepath.Clean(ws)
+	sum := sha1.Sum([]byte(ws))
+	return ws, hex.EncodeToString(sum[:])
+}
+
+/*
+AcquireWorkspaceLock 取工作空间锁（阻塞，直到拿到或超时）。
+
+	o.NoPersist 没关系：锁在 sessions 目录，不依赖会话记录落盘。
+	返回 nil 表示未启用（调用方无需处理）。
+*/
+func acquireWorkspaceLock(workspace string) (*WorkspaceLock, error) {
+	if !workspaceLockEnabled() {
+		return nil, nil
+	}
+	dir := Dir()
+	if dir == "" {
+		return nil, fmt.Errorf("cannot resolve sessions dir")
+	}
+	lockDir := filepath.Join(dir, "locks")
+	if err := os.MkdirAll(lockDir, 0o700); err != nil {
+		return nil, err
+	}
+	ws, name := workspaceLockKey(workspace)
+	path := filepath.Join(lockDir, name+".lock")
+	deadline := time.Now().Add(workspaceLockWait())
+	announced := false
+	for {
+		f, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
+		if err == nil {
+			_, _ = fmt.Fprintf(f, "%d\n%d\n", os.Getpid(), time.Now().UnixNano())
+			_ = f.Close()
+			return &WorkspaceLock{path: path, held: true}, nil
+		}
+		if !os.IsExist(err) {
+			return nil, err
+		}
+		if reapStaleWorkspaceLock(path) {
+			continue
+		}
+		if time.Now().After(deadline) {
+			return nil, fmt.Errorf("等待工作空间 %s 上的上一个任务超时（%s），可用 %s 调整", ws, workspaceLockWait(), EnvWorkspaceLockWait)
+		}
+		if !announced {
+			announced = true
+			fmt.Fprintf(os.Stderr, "magic-agent: 同一工作空间已有任务在跑，等待其结束（%s）…\n", ws)
+		}
+		time.Sleep(workspaceLockPoll)
+	}
+}
+
+// reapStaleWorkspaceLock 回收陈旧锁（pid 已不在 / 文件太老）；返回是否已删。
+func reapStaleWorkspaceLock(path string) bool {
+	st, err := os.Stat(path)
+	if err != nil {
+		return !os.IsNotExist(err) // 文件刚消失：让调用方重试
+	}
+	stale := time.Since(st.ModTime()) > workspaceLockStale
+	if !stale {
+		if b, err := os.ReadFile(path); err == nil {
+			lines := strings.Split(strings.TrimSpace(string(b)), "\n")
+			if len(lines) > 0 {
+				if pid, err := strconv.Atoi(strings.TrimSpace(lines[0])); err == nil {
+					if pid <= 0 || !agent.PIDAlive(pid) {
+						stale = true
+					}
+				}
+			}
+		}
+	}
+	if !stale {
+		return false
+	}
+	_ = os.Remove(path)
+	return true
+}
+
+// Release 释放锁；只删自己持有的那把（内容里的 pid 对得上）。
+func (l *WorkspaceLock) Release() {
+	if l == nil || !l.held {
+		return
+	}
+	l.held = false
+	b, err := os.ReadFile(l.path)
+	if err != nil {
+		return
+	}
+	first := strings.TrimSpace(strings.SplitN(string(b), "\n", 2)[0])
+	if first != strconv.Itoa(os.Getpid()) {
+		return
+	}
+	_ = os.Remove(l.path)
+}

package/internal/session/workspace_lock_test.go

@@ -0,0 +1,90 @@
+package session
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// 工作空间串行锁：同一 workspace 的第二轮必须等第一轮 Finish 之后才能 Begin。
+func TestWorkspaceLockSerializesRuns(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	t.Setenv(EnvWorkspaceLock, "1")
+	t.Setenv(EnvWorkspaceLockWait, "5s")
+	ws := t.TempDir()
+
+	h1, err := Begin(BeginOptions{NoPersist: true, Workspace: ws, Engine: "claude"})
+	if err != nil {
+		t.Fatalf("第一轮 Begin 失败：%v", err)
+	}
+
+	got := make(chan *Handle, 1)
+	go func() {
+		h2, err := Begin(BeginOptions{NoPersist: true, Workspace: ws, Engine: "claude"})
+		if err != nil {
+			got <- nil
+			return
+		}
+		got <- h2
+	}()
+
+	select {
+	case h := <-got:
+		if h != nil {
+			h.Finish("", StateDone)
+		}
+		t.Fatal("第一轮还没结束，第二轮不应拿到锁")
+	case <-time.After(400 * time.Millisecond):
+	}
+
+	h1.Finish("", StateDone)
+	select {
+	case h2 := <-got:
+		if h2 == nil {
+			t.Fatal("第一轮结束后，第二轮应拿到锁")
+		}
+		h2.Finish("", StateDone)
+	case <-time.After(4 * time.Second):
+		t.Fatal("第一轮结束后，第二轮仍未拿到锁")
+	}
+}
+
+// 持锁进程已不在（崩溃 / 被 kill）：下一次 Begin 要能回收陈旧锁。
+func TestWorkspaceLockReapsDeadOwner(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+	t.Setenv(EnvWorkspaceLock, "1")
+	t.Setenv(EnvWorkspaceLockWait, "2s")
+	ws := t.TempDir()
+
+	_, name := workspaceLockKey(ws)
+	lockDir := filepath.Join(dir, "locks")
+	if err := os.MkdirAll(lockDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	// 一个几乎不可能存活、但格式合法的 pid。
+	if err := os.WriteFile(filepath.Join(lockDir, name+".lock"), []byte("999999\n"+strconv.FormatInt(time.Now().UnixNano(), 10)+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	done := make(chan *Handle, 1)
+	go func() {
+		h, err := Begin(BeginOptions{NoPersist: true, Workspace: ws})
+		if err != nil {
+			done <- nil
+			return
+		}
+		done <- h
+	}()
+	select {
+	case h := <-done:
+		if h == nil {
+			t.Fatal("陈旧锁应被回收，第二轮应拿到锁")
+		}
+		h.Finish("", StateDone)
+	case <-time.After(3 * time.Second):
+		t.Fatal("陈旧锁未被回收：第二轮一直等")
+	}
+}

package/internal/suggest/suggest.go

@@ -190,7 +190,7 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 	start := time.Now()
 
 	/* 建议一律不思考；所有引擎都尽量走官方开关：
-	   llm 用 no-think 变体 / reasoning_effort=none，claude --thinking disabled，
+	   llm 传 reasoning_effort=none，claude --thinking disabled，
 	   codex effort=none，codebuddy settings alwaysThinkingEnabled=false，
 	   dsh InitializeParams.reasoningEffort=off。没有可靠开关的引擎（trae/openclaw/arkclaw）
 	   仍会被 NoThinking 标记，失败后再降级 llm；不在这里预先改道。 */
@@ -228,7 +228,8 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 }
 
 // fastLLMModel 找 models.json 里第一条「不思考」的变体（extraBody.thinking.type=disabled）。
-// 建议是短文本，思考只会把 1s 拖成 4s；有这种条目就用它，不硬编码某个模型 id。
+// 仅用于**没有显式选模型**的建议默认值：M3.1-Flash 明确拒绝 reasoning_effort=none，
+// 默认走首条会直接 400。显式选中的模型只传参数，不换模型。
 func fastLLMModel() string {
 	list, err := agent.LoadLLMConfigModels()
 	if err != nil {
@@ -254,22 +255,6 @@ func llmModelDisablesThinking(m agent.LLMConfigModel) bool {
 	return strings.EqualFold(strings.TrimSpace(fmt.Sprint(th["type"])), "disabled")
 }
 
-// noThinkLLMModel 给建议选一个真正不思考的 llm 模型：
-// 用户选的模型本身就是 no-think 变体 → 用它；否则用 models.json 里第一条
-// thinking.disabled 变体；没有变体才退回用户选的模型（无法关闭，至少不阻断）。
-func noThinkLLMModel(selected string) string {
-	selected = strings.TrimSpace(selected)
-	if selected != "" {
-		if m, ok := agent.LookupLLMConfigModel(selected); ok && llmModelDisablesThinking(m) {
-			return m.ID
-		}
-	}
-	if fast := fastLLMModel(); fast != "" {
-		return fast
-	}
-	return selected
-}
-
 // tryGenerate 用指定引擎跑一次 ToolsOff + JSONSchema 的短调用。
 func tryGenerate(ctx context.Context, in Request, name string, budget time.Duration, start time.Time) (Result, error) {
 	engine := agent.Lookup(name)
@@ -283,19 +268,17 @@ func tryGenerate(ctx context.Context, in Request, name string, budget time.Durat
 	   引擎的兜底（minimal 仍比默认高档轻）；能真正关闭的引擎看 NoThinking。 */
 	reasoning := "minimal"
 	model := strings.TrimSpace(in.Model)
-	if name == DefaultEngine {
-		/* 建议一律不思考：llm 有 no-think 变体就用它（默认引擎不配模型时也走这里）。
-		   用户显式选了会思考的模型（如 MiniMax-M3.1-Flash）时，宁可换同文件的
-		   no-think 变体，也不让建议在思考上多花几秒；配置里没有变体才保留原模型。 */
-		model = noThinkLLMModel(model)
+	if name == DefaultEngine && model == "" {
+		// 仅默认值：显式选了模型就只传 reasoning_effort=none，不换模型。
+		model = fastLLMModel()
 	}
 	runner := &agent.Runner{Engine: engine, Timeout: budget}
 	resp, err := runner.Run(attemptCtx, agent.Request{
 		Model: model,
 		Tools: agent.ToolsOff,
 		/* NoThinking：claude → --thinking disabled，codex → effort none，
-		   llm 换成 thinking.disabled 变体，codebuddy → settings:false，
-		   dsh → initialize.reasoningEffort=off。 */
+		   codebuddy → settings:false，dsh → initialize.reasoningEffort=off，
+		   llm → reasoning_effort=none（不自动换模型）。 */
 		NoThinking: true,
 		Reasoning:  reasoning,
 		MaxTokens:  300,

package/internal/suggest/suggest_test.go

@@ -259,10 +259,4 @@ func TestFastLLMModelPicksNoThinkVariant(t *testing.T) {
 	if got := fastLLMModel(); got != "fast-nothink" {
 		t.Fatalf("fastLLMModel = %q, want fast-nothink", got)
 	}
-	if got := noThinkLLMModel("slow"); got != "fast-nothink" {
-		t.Fatalf("noThinkLLMModel(slow) = %q, want fast-nothink（用户选了会思考的模型也要换成 no-think）", got)
-	}
-	if got := noThinkLLMModel("fast-nothink"); got != "fast-nothink" {
-		t.Fatalf("noThinkLLMModel(fast-nothink) = %q, want 原样保留", got)
-	}
 }

package/npm/apk/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.2",
-  "versionCode": 20302,
-  "builtAt": "2026-10-23T03:26:46.892Z"
+  "version": "2.4.2",
+  "versionCode": 20402,
+  "builtAt": "2026-10-23T11:49:45.889Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "2.3.2",
+  "version": "2.4.2",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {