magic-agent 2.4.3 → 2.6.3

package/internal/client/jobs_test.go

@@ -10,21 +10,62 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/darren/magic-agent/internal/session"
 )
 
 /* 服务端作业队列的回归闸门（2026-10-23）：
    · 同一 workspace 串行、不同 workspace 并行；
    · request_id 幂等（重复提交不多跑一遍）；
    · 排队中可取消，取消后不会偷偷开跑；
+   · 排队作业可改 serial（客户端切模式马上生效，2026-10-24）；并行作业不等同空间的串行作业收尾；
+   · 全局满员时串行照常排队、并行借 headroom 余量放行（2026-10-24「hi」无响应事故）；
    · 落盘 + 重启恢复（queued 留着、running 标失败）。 */
 
 // jobCore 假 core：记下每一次「真正开跑」的参数，然后停在 stdin 上等 stop。
+// Windows 上 exec 不了 shebang 脚本（CreateProcess 不认 #!，报 executable file not found），
+// 改发同名 .bat（Go 的 exec 在 Windows 会用 cmd.exe 跑批处理），语义与 sh 版逐条对齐。
 func jobCore(t *testing.T) string {
 	t.Helper()
 	dir := t.TempDir()
+	if runtime.GOOS == "windows" {
+		path := filepath.Join(dir, "magic-agent.bat")
+		// 批处理必须 CRLF（LF-only 的 goto 标签扫描有历史 bug）；逐行对齐 sh 版逻辑。
+		lines := []string{
+			`@echo off`,
+			`set "A=%*"`,
+			`if "%A:--contract=%" == "%A%" goto engines`,
+			`echo {"contractVersion":2,"features":["feature.session.events","feature.session.control"],"engines":[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]}`,
+			`exit /b 0`,
+			`:engines`,
+			`if "%A:--engines=%" == "%A%" goto sessions`,
+			`echo [{"engine":"claude","ok":true,"capabilities":["session.stream"]}]`,
+			`exit /b 0`,
+			`:sessions`,
+			`if "%A:--sessions=%" == "%A%" goto run`,
+			`echo []`,
+			`exit /b 0`,
+			`:run`,
+			`if defined JOB_TEST_LOG >>"%JOB_TEST_LOG%" echo %A%`,
+			`echo {"v":1,"seq":1,"type":"ready","engine":"claude"}`,
+			`echo {"v":1,"seq":2,"type":"text","text":"ok"}`,
+			`:loop`,
+			`set "line="`,
+			`set /p line=`,
+			`if not defined line exit /b 0`,
+			`if not "%line:stop=%" == "%line%" echo {"v":1,"seq":3,"type":"result"}`,
+			`if not "%line:stop=%" == "%line%" exit /b 0`,
+			`goto loop`,
+		}
+		if err := os.WriteFile(path, []byte(strings.Join(lines, "\r\n")+"\r\n"), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		return path
+	}
 	path := filepath.Join(dir, "magic-agent")
 	script := `#!/bin/sh
 case "$*" in
@@ -65,6 +106,9 @@ func jobTestService(t *testing.T, core string) (*Service, string) {
 	t.Setenv("MAGIC_CLIENT_JOBS_DIR", filepath.Join(dir, "jobs"))
 	t.Setenv("MAGIC_CLIENT_MAX_RUNNING", "8")
 	t.Setenv("JOB_TEST_LOG", logPath)
+	/* 作业受理即写会话登记占位（RegisterQueued）：登记表是**全机共享**的，
+	   不隔离的话测试会在开发者真实的 ~/.magic-agent/sessions 里堆一堆 queued 行。 */
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
 	svc, err := New(Options{MagicAgent: core, Profile: DefaultProfile(), Token: "tok"})
 	if err != nil {
 		t.Fatalf("New: %v", err)
@@ -147,6 +191,50 @@ func readRuns(t *testing.T, path string) []string {
 	return out
 }
 
+// waitRuns 等日志里出现 n 次「真正开跑」再断言：running 状态在 spawn **之前**就落定
+// （jobs.go dispatch），假 core 要等进程起来才写日志 —— Windows 上 cmd 冷启动可能
+// 比一轮状态轮询还慢，读一次就断言会跟进程启动竞速。
+func waitRuns(t *testing.T, path string, n int) []string {
+	t.Helper()
+	deadline := time.Now().Add(5 * time.Second)
+	for {
+		runs := readRuns(t, path)
+		if len(runs) >= n {
+			return runs
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("日志应在超时前出现 %d 次开跑，实际 %d：%v", n, len(runs), runs)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// sessionRecord 按 run_id 查会话登记表（排队占位的 run_id = request_id）。
+func sessionRecord(id string) (session.Record, bool) {
+	recs, _ := session.List()
+	for _, r := range recs {
+		if r.RunID == id {
+			return r, true
+		}
+	}
+	return session.Record{}, false
+}
+
+// waitNoRecord 等某条登记记录消失（占位撤除是落盘动作，与状态轮询不完全同拍）。
+func waitNoRecord(t *testing.T, id string, timeout time.Duration) {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	for {
+		if _, ok := sessionRecord(id); !ok {
+			return
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("会话登记里的 %s 应在 %s 内消失（排队占位没撤）", id, timeout)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
 func TestJobsSerialPerWorkspace(t *testing.T) {
 	svc, runs := jobTestService(t, jobCore(t))
 	srv := httptest.NewServer(svc.Handler())
@@ -158,6 +246,9 @@ func TestJobsSerialPerWorkspace(t *testing.T) {
 		t.Errorf("刚提交应是 queued，实际 %s", j1.State)
 	}
 	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	/* 受理即登记（2026-10-24 用户：「没跑也先登记啊」）：开跑后排队占位要抹掉，
+	   交给 core 自己那条 running 记录 —— 否则列表里会有两行（占位 + 真会话）。 */
+	waitNoRecord(t, "r1", 3*time.Second)
 
 	j2 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "二", "workspace": ws, "serial": true, "request_id": "r2"})
 	time.Sleep(600 * time.Millisecond) // 给调度器足够时间：它**不该**开第二条
@@ -165,6 +256,18 @@ func TestJobsSerialPerWorkspace(t *testing.T) {
 	if j2.State != JobQueued {
 		t.Fatalf("同 workspace 第二条必须排队，实际 %s", j2.State)
 	}
+	/* 排队中的那条此刻**还没开跑**，但必须已经在会话登记表里（列表页据此显示它），
+	   且 id 用客户端幂等键 —— 客户端靠它把本地那条「等待中」和登记行认成同一条。 */
+	rec, ok := sessionRecord("r2")
+	if !ok {
+		t.Fatalf("排队中的作业应在会话登记表里先登记一行（request_id=r2）")
+	}
+	if rec.State != session.StateQueued {
+		t.Fatalf("排队占位 state 应为 queued，实际 %q（%+v）", rec.State, rec)
+	}
+	if rec.Client == "" || rec.PromptHead == "" {
+		t.Fatalf("排队占位缺来源客户端 / 提示词，列表页画不出来：%+v", rec)
+	}
 	if got := len(readRuns(t, runs)); got != 1 {
 		t.Fatalf("同 workspace 只应有 1 次真正开跑，实际 %d：%v", got, readRuns(t, runs))
 	}
@@ -181,6 +284,8 @@ func TestJobsSerialPerWorkspace(t *testing.T) {
 	if j2.State != JobCancelled {
 		t.Fatalf("取消失败：%+v", j2)
 	}
+	/* 取消排队后登记占位也要撤掉：留着就是一条永远「等待中」的幽灵行。 */
+	waitNoRecord(t, "r2", 3*time.Second)
 
 	// 停掉第一条，槽位释放。
 	cr2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/cancel", nil)
@@ -205,8 +310,9 @@ func TestJobsParallelAcrossWorkspaces(t *testing.T) {
 	b := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "b", "workspace": wsB, "serial": true, "request_id": "pb"})
 	waitJob(t, srv.URL, a.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
 	waitJob(t, srv.URL, b.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
-	if got := len(readRuns(t, runs)); got != 2 {
-		t.Fatalf("不同 workspace 应并行开跑（2 次），实际 %d：%v", got, readRuns(t, runs))
+	started := waitRuns(t, runs, 2)
+	if len(started) != 2 {
+		t.Fatalf("不同 workspace 应并行开跑（2 次），实际 %d：%v", len(started), started)
 	}
 	for _, id := range []string{a.ID, b.ID} {
 		r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+id+"/cancel", nil)
@@ -217,6 +323,41 @@ func TestJobsParallelAcrossWorkspaces(t *testing.T) {
 	}
 }
 
+// 全局并发满员（max）时：串行新作业照常排队，并行作业借 headroom 余量放行 ——
+// 交互式轻活不能被一批长任务压死（2026-10-24「hi」无响应事故的复发路径）。
+func TestJobsParallelHeadroomWhenFull(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	// jobTestService 把 MAGIC_CLIENT_MAX_RUNNING 固定成 8：
+	// 先放 8 条串行（各占一个 workspace）把全局名额占满。
+	var fill []*Job
+	for i := 0; i < 8; i++ {
+		j := postJob(t, srv.URL, map[string]any{
+			"engine": "claude", "prompt": fmt.Sprintf("占位%d", i),
+			"workspace": t.TempDir(), "serial": true, "request_id": fmt.Sprintf("full-%d", i),
+		})
+		fill = append(fill, j)
+	}
+	for _, j := range fill {
+		waitJob(t, srv.URL, j.ID, func(x *Job) bool { return x.State == JobRunning }, 10*time.Second)
+	}
+
+	// 第 9 条串行：满员 → 必须排队。
+	s9 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "第九", "workspace": t.TempDir(), "serial": true, "request_id": "full-9"})
+	time.Sleep(600 * time.Millisecond) // 给调度器足够时间：它不该开这条
+	if got := getJob(t, srv.URL, s9.ID); got.State != JobQueued {
+		t.Fatalf("满员后串行作业应排队，实际 %s", got.State)
+	}
+
+	// 并行作业：headroom 余量 → 立即放行。
+	p := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "并行", "workspace": t.TempDir(), "serial": false, "request_id": "full-p"})
+	waitJob(t, srv.URL, p.ID, func(x *Job) bool { return x.State == JobRunning }, 5*time.Second)
+
+	waitRuns(t, runs, 9)
+}
+
 func TestJobsIdempotentRequestID(t *testing.T) {
 	svc, runs := jobTestService(t, jobCore(t))
 	srv := httptest.NewServer(svc.Handler())
@@ -244,6 +385,8 @@ func TestJobsIdempotentRequestID(t *testing.T) {
 func TestJobQueueRecoversAfterRestart(t *testing.T) {
 	dir := t.TempDir()
 	t.Setenv("MAGIC_CLIENT_JOBS_DIR", dir)
+	/* 登记表是全机共享的：不隔离的话启动对账会动开发者真实的 ~/.magic-agent/sessions。 */
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
 	now := time.Now()
 	running := Job{
 		ID: "job-running", Workspace: "/tmp/ws", Engine: "claude", Prompt: "旧的",
@@ -275,6 +418,70 @@ func TestJobQueueRecoversAfterRestart(t *testing.T) {
 	}
 }
 
+/*
+启动对账：作业已经不在的排队占位要清掉（幽灵「等待中」行，2026-10-24 用户：「清掉」）。
+
+	台阶：本客户端的陈迹 → 删；仍在排队的 → 留；刚写的（窗口期）→ 留；别的客户端的 → 不碰。
+*/
+func TestJobsPruneOrphanQueuedPlaceholder(t *testing.T) {
+	dir := t.TempDir()
+	jobsDir := filepath.Join(dir, "jobs")
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", jobsDir)
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
+	if err := os.MkdirAll(jobsDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Now()
+	/* 一个**还排着**的作业：它的占位必须留着。 */
+	live := Job{
+		ID: "job-live", RequestID: "req-live", Workspace: "/tmp/ws", Engine: "claude", Prompt: "排队",
+		State: JobQueued, Serial: true, CreatedAt: now, UpdatedAt: now, ExpiresAt: now.Add(time.Hour),
+	}
+	b, _ := json.Marshal(live)
+	if err := os.WriteFile(filepath.Join(jobsDir, live.ID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	ours := DefaultProfile().AppID()
+	old := now.Add(-10 * time.Minute)
+	writePlaceholder(t, "req-live", ours, old)          // 对应上面的作业 → 留
+	writePlaceholder(t, "req-ghost", ours, old)         // 作业文件早没了 → 删
+	writePlaceholder(t, "req-fresh", ours, now)         // 刚写（落盘窗口期）→ 留
+	writePlaceholder(t, "req-other", "magic-test", old) // 别的客户端 → 不碰
+
+	svc := &Service{opts: Options{Profile: DefaultProfile()}, log: log.New(io.Discard, "", 0), runs: map[string]*askRun{}}
+	q := newJobQueue(svc)
+	defer q.close()
+
+	if _, ok := sessionRecord("req-ghost"); ok {
+		t.Error("作业已不存在的排队占位应被清掉（否则列表上是一条永远「等待中」的幽灵行）")
+	}
+	for _, id := range []string{"req-live", "req-fresh", "req-other"} {
+		if _, ok := sessionRecord(id); !ok {
+			t.Errorf("占位 %s 不该被清（仍在排队 / 刚写入 / 别的客户端）", id)
+		}
+	}
+}
+
+// writePlaceholder 直接落一条排队占位（时间可控，绕过 RegisterQueued 的「写当前时间」）。
+func writePlaceholder(t *testing.T, id, client string, at time.Time) {
+	t.Helper()
+	rec := session.Record{
+		RunID: id, Client: client, PromptHead: "占位", Cwd: "/tmp/ws",
+		State: session.StateQueued, StartedAt: at, UpdatedAt: at,
+	}
+	b, err := json.Marshal(rec)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(session.Dir(), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(session.Dir(), id+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestAskIdempotentRequestID(t *testing.T) {
 	svc, runs := jobTestService(t, jobCore(t))
 	srv := httptest.NewServer(svc.Handler())
@@ -367,3 +574,93 @@ func TestJobsListAndSnapshot(t *testing.T) {
 		resp.Body.Close()
 	}
 }
+
+func TestJobsUpdateSerialTakesEffect(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+
+	// 第一条串行占住同空间单槽；第二条（也是串行）只能排队。
+	j1 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "占位", "workspace": ws, "serial": true, "request_id": "u1"})
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	j2 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "排队", "workspace": ws, "serial": true, "request_id": "u2"})
+	time.Sleep(600 * time.Millisecond)
+	if j2 = getJob(t, srv.URL, j2.ID); j2.State != JobQueued {
+		t.Fatalf("同 workspace 第二条应排队，实际 %s", j2.State)
+	}
+
+	// 客户端切到并行模式：按 request_id 把排队的第二条改成并行 —— 应立刻放行，
+	// 与还在跑的第一条同空间并行（不再让路、core 侧锁也只对串行注入）。
+	req, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/update",
+		bytes.NewReader([]byte(`{"request_id":"u2","serial":false}`)))
+	req.Header.Set("X-Magic-Token", "tok")
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out struct {
+		Job     *Job `json:"job"`
+		Updated bool `json:"updated"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusOK || !out.Updated {
+		t.Fatalf("update 应成功，实际 HTTP %d updated=%v", resp.StatusCode, out.Updated)
+	}
+	if out.Job.Serial {
+		t.Errorf("改完 serial 标志应落到作业上：%+v", out.Job)
+	}
+	waitJob(t, srv.URL, j2.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	started := waitRuns(t, runs, 2)
+	if len(started) != 2 {
+		t.Fatalf("并行化后应与第一条同空间并行开跑（2 次），实际 %d：%v", len(started), started)
+	}
+
+	// 已开跑的作业改不动（updated=false），也不被打断。
+	req2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/update",
+		bytes.NewReader([]byte(`{"serial":true}`)))
+	req2.Header.Set("X-Magic-Token", "tok")
+	req2.Header.Set("Content-Type", "application/json")
+	resp2, err := http.DefaultClient.Do(req2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out2 struct {
+		Job     *Job `json:"job"`
+		Updated bool `json:"updated"`
+	}
+	if err := json.NewDecoder(resp2.Body).Decode(&out2); err != nil {
+		t.Fatal(err)
+	}
+	resp2.Body.Close()
+	if out2.Updated || out2.Job == nil || out2.Job.State != JobRunning {
+		t.Fatalf("running 作业不应被改（updated=%v job=%+v）", out2.Updated, out2.Job)
+	}
+
+	// 缺 serial 字段 → 400。
+	req3, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/update",
+		bytes.NewReader([]byte(`{"request_id":"u2"}`)))
+	req3.Header.Set("X-Magic-Token", "tok")
+	resp3, err := http.DefaultClient.Do(req3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	io.Copy(io.Discard, resp3.Body)
+	resp3.Body.Close()
+	if resp3.StatusCode != http.StatusBadRequest {
+		t.Fatalf("缺 serial 应 400，实际 %d", resp3.StatusCode)
+	}
+
+	// 收尾。
+	for _, id := range []string{j1.ID, j2.ID} {
+		r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+id+"/cancel", nil)
+		r.Header.Set("X-Magic-Token", "tok")
+		if resp, err := http.DefaultClient.Do(r); err == nil {
+			resp.Body.Close()
+		}
+	}
+}