Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

23.2 KB
Raw Blame
package agent

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"runtime"
	"slices"
	"strings"
	"testing"

	"github.com/yetone/magpie/internal/provider"
)

// kiroCrewUser is config.json as Kiro Crew's dashboard saves it: the
// user's own settings beside the agent section, and the harness the user
// chose for crew members.
const kiroCrewUser = `{
  "agent": {
    "default_agent": "kirocrew",
    "member_acp_backend": "kas",
    "model": "auto"
  },
  "gateway": {"port": 5476},
  "ui": {"theme": "dark"}
}
`

// kiroCrewSandbox is a sandbox HOME with Kiro Crew's home in it, the
// harnesses connected to magpie as wired says and the adapters as found.
func kiroCrewSandbox(t *testing.T, wired []string, found []string) (home string, a *Agent) {
	t.Helper()
	home = syncHome(t)
	t.Setenv("KIROCREW_HOME", "")
	if err := provider.Save(provider.Provider{ID: "deepseek", Name: "DeepSeek", Chat: "https://api.deepseek.com/v1", Key: "k", Models: []string{"pro", "flash"}}); err != nil {
		t.Fatal(err)
	}
	w, h, j := kiroCrewWired, kiroCrewHasAdapter, kiroCrewJoin
	t.Cleanup(func() { kiroCrewWired, kiroCrewHasAdapter, kiroCrewJoin = w, h, j })
	kiroCrewWired = func(id string) bool { return slices.Contains(wired, id) }
	// none of the harnesses is installed here, so none is connected along
	kiroCrewJoin = func(string) (bool, error) { return false, nil }
	kiroCrewHasAdapter = func(h kiroCrewHarness) bool { return slices.Contains(found, h.id) }
	a = kiroCrew(home)
	if err := os.MkdirAll(a.Dir, 0o700); err != nil {
		t.Fatal(err)
	}
	return home, a
}

func kiroCrewKey(t *testing.T, path, key string) (any, bool) {
	t.Helper()
	b, err := os.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	var m map[string]any
	if err := json.Unmarshal(b, &m); err != nil {
		t.Fatalf("%s: %v", b, err)
	}
	var cur any = m
	for _, k := range strings.Split(key, ".") {
		o, ok := cur.(map[string]any)
		if !ok {
			return nil, false
		}
		if cur, ok = o[k]; !ok {
			return nil, false
		}
	}
	return cur, true
}

// Connecting Kiro Crew runs it on Codex, connected to magpie, and its crew
// members too; Disconnect puts back what the user had, byte for byte, and
// every other setting stays.
func TestKiroCrewConnect(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"codex", "claude"}, []string{"codex", "claude"})
	if !slices.ContainsFunc(All(), func(x *Agent) bool { return x.ID == "kirocrew" && x.Name == "Kiro Crew" }) {
		t.Fatal("Kiro Crew is not among the agents")
	}
	if a.Detected() {
		t.Fatal("found with no settings, app or command")
	}
	os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
	if !a.Detected() {
		t.Fatal("not found with its config.json")
	}
	if a.Wired() {
		t.Fatal("wired before connecting")
	}
	c, err := a.ConnectHow()
	if err != nil {
		t.Fatal(err)
	}
	if c.How != "magpie" || !a.Wired() {
		t.Fatalf("connect: %+v, wired %v", c, a.Wired())
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewBackend); v != "codex" {
		t.Errorf("acp_backend %v", v)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewMember); v != "codex" {
		t.Errorf("member_acp_backend %v", v)
	}
	if v := a.Values(); v["provider"] != magpieID || v["harness"] != "codex" {
		t.Errorf("values %v", v)
	}
	if n := a.Notice(); n != noticeKiroCrew.String() {
		t.Errorf("notice %q", n)
	}
	for _, k := range []string{"agent.default_agent", "agent.model", "gateway.port", "ui.theme"} {
		if _, ok := kiroCrewKey(t, a.Path, k); !ok {
			t.Errorf("%s is gone", k)
		}
	}
	// connecting again changes nothing
	b1, _ := os.ReadFile(a.Path)
	if err := a.Field("provider").Set(magpieID); err != nil {
		t.Fatal(err)
	}
	if b2, _ := os.ReadFile(a.Path); string(b1) != string(b2) {
		t.Errorf("set again rewrote it:\n%s", b2)
	}

	if err := a.Disconnect(); err != nil {
		t.Fatal(err)
	}
	if a.Wired() {
		t.Fatal("wired after disconnecting")
	}
	var was, now map[string]any
	json.Unmarshal([]byte(kiroCrewUser), &was)
	b, _ := os.ReadFile(a.Path)
	json.Unmarshal(b, &now)
	if !sameJSON(string(b), was) {
		t.Errorf("after disconnect:\n%s\nwant\n%s", b, kiroCrewUser)
	}
	if s := stashLoad(); s[kiroCrewWasKey] != "" || s[kiroCrewWroteKey] != "" {
		t.Errorf("stash kept: %v", s)
	}
}

// With no harness connected to magpie, connecting says to connect one and
// writes nothing; the harness picked by itself is Codex, then Claude Code,
// one whose adapter is here before one whose isn't, and a harness with no
// adapter's install says how to install it.
func TestKiroCrewPicksAHarness(t *testing.T) {
	_, a := kiroCrewSandbox(t, nil, nil)
	os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
	if _, err := a.ConnectHow(); !errors.Is(err, errKiroCrewNoHarness) {
		t.Fatalf("no harness: %v", err)
	}
	if b, _ := os.ReadFile(a.Path); string(b) != kiroCrewUser {
		t.Errorf("written with no harness:\n%s", b)
	}
	if len(a.Field("harness").Options(nil)) != 0 {
		t.Errorf("harnesses offered with none connected: %v", a.Field("harness").Options(nil))
	}

	for _, c := range []struct {
		wired, found []string
		want         string
		member       any
		notice       string
	}{
		{wired: []string{"claude", "codex", "goose"}, found: []string{"claude", "codex"}, want: "codex", member: "codex"},
		{wired: []string{"claude", "codex"}, found: []string{"claude"}, want: "claude", member: "claude"},
		{wired: []string{"opencode", "pi"}, found: []string{"opencode", "pi"}, want: "opencode", member: "opencode"},
		// Pi can't run crew members: theirs stays the user's
		{wired: []string{"pi"}, found: []string{"pi"}, want: "pi", member: "kas"},
		{wired: []string{"codex"}, want: "codex", member: "codex",
			notice: "Kiro Crew runs Codex through codex-acp, which magpie didn't find here: install it with npm i -g @agentclientprotocol/codex-acp, then start a new session."},
		// deepseek is no harness of magpie's
		{wired: []string{"dsh", "deepseek"}},
	} {
		_, a := kiroCrewSandbox(t, c.wired, c.found)
		os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
		_, err := a.ConnectHow()
		if c.want == "" {
			if !errors.Is(err, errKiroCrewNoHarness) {
				t.Errorf("%v: %v", c.wired, err)
			}
			continue
		}
		if err != nil {
			t.Fatalf("%v: %v", c.wired, err)
		}
		if v, _ := kiroCrewKey(t, a.Path, kiroCrewBackend); v != c.want {
			t.Errorf("%v %v: picked %v, want %s", c.wired, c.found, v, c.want)
		}
		if v, _ := kiroCrewKey(t, a.Path, kiroCrewMember); v != c.member {
			t.Errorf("%v: member %v, want %v", c.wired, v, c.member)
		}
		var opts []string
		for _, o := range a.Field("harness").Options(nil) {
			opts = append(opts, o.Value)
		}
		var want []string
		for _, h := range kiroCrewHarnesses {
			if slices.Contains(c.wired, h.id) {
				want = append(want, h.id)
			}
		}
		if !slices.Equal(opts, want) {
			t.Errorf("%v: offered %v", c.wired, opts)
		}
		n := a.Notice()
		if c.notice != "" && !strings.Contains(n, c.notice) || c.notice == "" && n != noticeKiroCrew.String() {
			t.Errorf("%v: notice %q", c.wired, n)
		}
		if err := a.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if b, _ := os.ReadFile(a.Path); !sameJSON(string(b), json.RawMessage(kiroCrewUser)) {
			t.Errorf("%v: after disconnect:\n%s", c.wired, b)
		}
	}
}

// The harness picked on the row is written, its crew members' with it;
// one not connected to magpie is refused. Disconnect after a pick puts
// back the user's, and the pick comes back on connecting again.
func TestKiroCrewHarnessPick(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"codex", "claude", "pi"}, []string{"codex", "claude", "pi"})
	os.WriteFile(a.Path, []byte(`{"agent":{"acp_backend":"kas","member_acp_backend":"kas"}}`), 0o600)
	if err := a.Pick("harness", "goose"); !errors.Is(err, errKiroCrewHarness) {
		t.Errorf("goose, not connected: %v", err)
	}
	if err := a.Pick("harness", "deepseek"); !errors.Is(err, errKiroCrewHarness) {
		t.Errorf("deepseek: %v", err)
	}
	if err := a.Pick("harness", "claude"); err != nil {
		t.Fatal(err)
	}
	if v := a.Values(); v["provider"] != magpieID || v["harness"] != "claude" {
		t.Fatalf("values %v", v)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewMember); v != "claude" {
		t.Errorf("member %v", v)
	}
	// Pi runs no crew members: theirs stays magpie's Claude Code
	if err := a.Pick("harness", "pi"); err != nil {
		t.Fatal(err)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewBackend); v != "pi" {
		t.Errorf("backend %v", v)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewMember); v != "claude" {
		t.Errorf("member %v", v)
	}
	if err := a.Pick("harness", "claude"); err != nil {
		t.Fatal(err)
	}
	if err := a.Disconnect(); err != nil {
		t.Fatal(err)
	}
	b, _ := os.ReadFile(a.Path)
	if !sameJSON(string(b), json.RawMessage(`{"agent":{"acp_backend":"kas","member_acp_backend":"kas"}}`)) {
		t.Errorf("after disconnect: %s", b)
	}
	if _, err := a.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	if v := a.Values()["harness"]; v != "claude" {
		t.Errorf("reconnected on %q, not the harness picked before", v)
	}
}

// A harness set in config.local.json wins over config.json, so magpie
// writes none: connecting is refused and says so, nothing is written, and
// the row's note and notice say why.
func TestKiroCrewLocalPin(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"codex"}, []string{"codex"})
	os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
	local := filepath.Join(a.Dir, "config.local.json")
	os.WriteFile(local, []byte(`{"agent":{"acp_backend":""}}`), 0o600)
	if _, err := a.ConnectHow(); !errors.Is(err, errKiroCrewPinned) {
		t.Fatalf("pinned: %v", err)
	}
	if b, _ := os.ReadFile(a.Path); string(b) != kiroCrewUser {
		t.Errorf("config.json written:\n%s", b)
	}
	if b, _ := os.ReadFile(local); string(b) != `{"agent":{"acp_backend":""}}` {
		t.Errorf("config.local.json written: %s", b)
	}
	if a.Wired() {
		t.Error("wired")
	}
	if n := a.Notice(); n != noticeKiroCrewPinned.String() {
		t.Errorf("notice %q", n)
	}
	if o := a.Field("provider").Options(nil); o[0].Note != kiroCrewPinnedNote {
		t.Errorf("note %q", o[0].Note)
	}
	// set there after magpie connected it: what Kiro Crew runs is the
	// user's, and magpie isn't said to be its provider
	os.Remove(local)
	if _, err := a.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	os.WriteFile(local, []byte(`{"agent":{"acp_backend":"kas"}}`), 0o600)
	if a.Wired() {
		t.Error("wired with the local pin on kas")
	}
	// on a harness of magpie's: connected
	os.WriteFile(local, []byte(`{"agent":{"acp_backend":"codex"}}`), 0o600)
	if !a.Wired() {
		t.Error("not wired with the local pin on Codex")
	}
}

// A harness no longer connected to magpie leaves Kiro Crew not connected,
// and a harness the user set in Kiro Crew since is kept by Disconnect.
func TestKiroCrewFollowsItsHarness(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"codex"}, []string{"codex"})
	os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
	if _, err := a.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	kiroCrewWired = func(string) bool { return false }
	if a.Wired() {
		t.Error("wired with Codex off magpie")
	}
	kiroCrewWired = func(id string) bool { return id == "codex" }
	// the user moves it to kiro-cli and its members to Claude in Kiro Crew
	if err := setJSONFile(a.Path, map[string]any{kiroCrewBackend: "", kiroCrewMember: "claude"}); err != nil {
		t.Fatal(err)
	}
	if a.Wired() {
		t.Error("wired on kiro-cli")
	}
	if err := a.Field("provider").Set(""); err != nil {
		t.Fatal(err)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewBackend); v != "" {
		t.Errorf("backend %v, the user's \"\" written over", v)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewMember); v != "claude" {
		t.Errorf("member %v, the user's claude written over", v)
	}
}

// config.json not there yet (the app installed, never started): magpie
// makes it with the one key, and takes it out again on Disconnect.
func TestKiroCrewMakesItsFile(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"opencode"}, []string{"opencode"})
	if _, err := a.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	if v, _ := kiroCrewKey(t, a.Path, kiroCrewBackend); v != "opencode" {
		t.Errorf("backend %v", v)
	}
	if err := a.Disconnect(); err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(a.Path); !os.IsNotExist(err) {
		b, _ := os.ReadFile(a.Path)
		t.Errorf("config.json magpie made is still there: %s", b)
	}
}

// A config.json that isn't JSON is left alone.
func TestKiroCrewLeavesBrokenAlone(t *testing.T) {
	_, a := kiroCrewSandbox(t, []string{"codex"}, []string{"codex"})
	bad := `{"agent": {"acp_backend": "kas",`
	os.WriteFile(a.Path, []byte(bad), 0o600)
	if _, err := a.ConnectHow(); err == nil {
		t.Error("connected over a broken config.json")
	}
	if b, _ := os.ReadFile(a.Path); string(b) != bad {
		t.Errorf("written: %s", b)
	}
}

// Kiro Crew's home is KIROCREW_HOME, ~ and a relative path made absolute,
// unless it is one Kiro Crew refuses; else ~/.kiro/crew.
func TestKiroCrewHome(t *testing.T) {
	home := t.TempDir()
	env := func(v string) func(string) string {
		return func(k string) string {
			if k == "KIROCREW_HOME" {
				return v
			}
			return ""
		}
	}
	def := filepath.Join(home, ".kiro", "crew")
	if got := kiroCrewHome(home, env("")); got != def {
		t.Errorf("default %s", got)
	}
	own := filepath.Join(home, "crew-two")
	os.MkdirAll(own, 0o700)
	own, _ = filepath.EvalSymlinks(own)
	if got := kiroCrewHome(home, env(own)); got != own {
		t.Errorf("KIROCREW_HOME %s", got)
	}
	if got, want := kiroCrewHome(home, env("~/x")), filepath.Join(home, "x"); got != want {
		t.Errorf("~/x: %s, want %s", got, want)
	}
	if runtime.GOOS != "windows" {
		for _, bad := range []string{"/", "/usr/local/crew", "/etc", "/System/x"} {
			if got := kiroCrewHome(home, env(bad)); got != def {
				t.Errorf("%s: %s, want the default", bad, got)
			}
		}
	}
	t.Setenv("HOME", home)
	t.Setenv("KIROCREW_HOME", own)
	if a := kiroCrew(home); a.Path != filepath.Join(own, "config.json") {
		t.Errorf("path %s", a.Path)
	}
}

// The adapter is found where Kiro Crew looks: the variable naming it, a
// Node version's bin, Crew's own folders; never one of another name.
func TestKiroCrewFindsAdapters(t *testing.T) {
	home := t.TempDir()
	t.Setenv("PATH", t.TempDir())
	codex, _ := kiroCrewHarnessOf("codex")
	env := map[string]string{}
	getenv := func(k string) string { return env[k] }
	if kiroCrewFinds(codex, home, getenv) {
		t.Fatal("found with none")
	}
	put := func(p string) {
		os.MkdirAll(filepath.Dir(p), 0o755)
		os.WriteFile(p, []byte("#!/bin/sh\n"), 0o755)
	}
	put(filepath.Join(home, ".nvm", "versions", "node", "v22.1.0", "bin", "claude-agent-acp"))
	if kiroCrewFinds(codex, home, getenv) {
		t.Error("codex-acp found as claude-agent-acp")
	}
	claude, _ := kiroCrewHarnessOf("claude")
	if !kiroCrewFinds(claude, home, getenv) {
		t.Error("claude-agent-acp under nvm not found")
	}
	put(filepath.Join(home, ".local", "share", "mise", "installs", "node", "24.0.0", "bin", "codex-acp"))
	if !kiroCrewFinds(codex, home, getenv) {
		t.Error("codex-acp under mise not found")
	}
	pi, _ := kiroCrewHarnessOf("pi")
	env["PI_ACP_BIN"] = filepath.Join(home, "elsewhere", "pi-acp")
	if kiroCrewFinds(pi, home, getenv) {
		t.Error("PI_ACP_BIN found with no file there")
	}
	put(env["PI_ACP_BIN"])
	if !kiroCrewFinds(pi, home, getenv) {
		t.Error("PI_ACP_BIN not found")
	}
}

// End to end, with magpie's own Codex wiring in the sandbox: Kiro Crew is
// offered Codex only once Codex is connected to magpie.
func TestKiroCrewOnRealCodexWiring(t *testing.T) {
	home := syncHome(t)
	t.Setenv("KIROCREW_HOME", "")
	if err := provider.Save(provider.Provider{ID: "deepseek", Name: "DeepSeek", Chat: "https://api.deepseek.com/v1", Key: "k", Models: []string{"pro", "flash"}}); err != nil {
		t.Fatal(err)
	}
	h := kiroCrewHasAdapter
	t.Cleanup(func() { kiroCrewHasAdapter = h })
	kiroCrewHasAdapter = func(kiroCrewHarness) bool { return true }
	a := kiroCrew(home)
	os.MkdirAll(a.Dir, 0o700)
	os.WriteFile(a.Path, []byte(kiroCrewUser), 0o600)
	if _, err := a.ConnectHow(); !errors.Is(err, errKiroCrewNoHarness) {
		t.Fatalf("before Codex: %v", err)
	}
	cx := codex(home)
	os.MkdirAll(cx.Dir, 0o755)
	if _, err := cx.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	if !cx.Wired() {
		t.Fatal("Codex not wired")
	}
	if _, err := a.ConnectHow(); err != nil {
		t.Fatal(err)
	}
	if v := a.Values(); v["provider"] != magpieID || v["harness"] != "codex" {
		t.Errorf("values %v", v)
	}
	if err := cx.Disconnect(); err != nil {
		t.Fatal(err)
	}
	if a.Wired() {
		t.Error("Kiro Crew still connected with Codex off magpie")
	}
}

// kiroCrewOnClaude is a sandbox HOME with Claude Code installed but not
// connected to magpie, nothing else, and Kiro Crew's config.json set to
// run on Claude Code, as wuping9525's Windows had it.
func kiroCrewOnClaude(t *testing.T) (a, cc *Agent, before []byte) {
	t.Helper()
	home := syncHome(t)
	t.Setenv("KIROCREW_HOME", "")
	t.Setenv("PATH", t.TempDir())
	if err := provider.Save(provider.Provider{ID: "deepseek", Name: "DeepSeek", Chat: "https://api.deepseek.com/v1", Key: "k", Models: []string{"pro", "flash"}}); err != nil {
		t.Fatal(err)
	}
	h := kiroCrewHasAdapter
	t.Cleanup(func() { kiroCrewHasAdapter = h })
	kiroCrewHasAdapter = func(kiroCrewHarness) bool { return true }
	cc = claude(home)
	if err := os.MkdirAll(cc.Dir, 0o755); err != nil {
		t.Fatal(err)
	}
	os.WriteFile(cc.Path, []byte("{\"theme\": \"dark\"}\n"), 0o600)
	if !cc.Detected() || cc.Wired() {
		t.Fatalf("Claude Code detected %v, wired %v", cc.Detected(), cc.Wired())
	}
	a = kiroCrew(home)
	os.MkdirAll(a.Dir, 0o700)
	before = []byte(strings.Replace(kiroCrewUser, `"default_agent": "kirocrew",`, `"acp_backend": "claude",
    "default_agent": "kirocrew",`, 1))
	if err := os.WriteFile(a.Path, before, 0o600); err != nil {
		t.Fatal(err)
	}
	return a, cc, before
}

// wuping9525: Kiro Crew set to Claude Code, Claude Code installed and not
// connected to magpie. Connecting Kiro Crew connects Claude Code too, in
// the one step, and runs Crew on it; Disconnect takes both off again and
// leaves the files as they were.
func TestKiroCrewConnectsItsHarness(t *testing.T) {
	a, cc, before := kiroCrewOnClaude(t)
	ccBefore, _ := os.ReadFile(cc.Path)
	if _, err := a.ConnectHow(); err != nil {
		t.Fatalf("connect: %v", err)
	}
	if !cc.Wired() {
		t.Fatal("Claude Code not connected along with Kiro Crew")
	}
	if v := a.Values(); v["provider"] != magpieID || v["harness"] != "claude" {
		t.Errorf("values %v", v)
	}
	if n := a.Notice(); !strings.Contains(n, "magpie connected Claude Code too") {
		t.Errorf("notice %q", n)
	}
	if err := a.Disconnect(); err != nil {
		t.Fatal(err)
	}
	if cc.Wired() {
		t.Error("Claude Code still connected after Kiro Crew's Disconnect")
	}
	if cc.Disconnected() {
		t.Error("Claude Code recorded as the user's own disconnect")
	}
	if b, _ := os.ReadFile(a.Path); string(b) != string(before) {
		t.Errorf("config.json\n%s\nwant\n%s", b, before)
	}
	// as Claude Code's own Disconnect leaves it: the user's settings kept,
	// nothing of magpie's
	if b, _ := os.ReadFile(cc.Path); !strings.Contains(string(b), `"theme": "dark"`) || strings.Contains(string(b), "ANTHROPIC") || strings.Contains(string(b), "magpie") {
		t.Errorf("Claude Code's settings.json\n%s\nwas\n%s", b, ccBefore)
	}
	if _, ok := stashLoad()[kiroCrewJoinedKey]; ok {
		t.Error("joined mark left")
	}
}

// A harness the user connected before is theirs: Kiro Crew runs on it and
// its Disconnect leaves it on. So is one the user disconnected and
// connected again themselves after Kiro Crew's connect.
func TestKiroCrewLeavesTheUsersHarness(t *testing.T) {
	t.Run("connected before", func(t *testing.T) {
		a, cc, _ := kiroCrewOnClaude(t)
		if _, err := cc.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if _, err := a.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if strings.Contains(a.Notice(), "magpie connected") {
			t.Errorf("notice %q", a.Notice())
		}
		if err := a.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if !cc.Wired() {
			t.Error("the user's Claude Code taken off")
		}
	})
	t.Run("taken back after", func(t *testing.T) {
		a, cc, _ := kiroCrewOnClaude(t)
		if _, err := a.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if err := cc.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if _, err := cc.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if _, err := a.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if err := a.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if !cc.Wired() {
			t.Error("Claude Code the user connected again taken off")
		}
	})
	t.Run("off before", func(t *testing.T) {
		// the user's disconnect from before stays theirs once Kiro Crew is off
		a, cc, _ := kiroCrewOnClaude(t)
		if _, err := cc.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if err := cc.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if _, err := a.ConnectHow(); err != nil {
			t.Fatal(err)
		}
		if !cc.Wired() {
			t.Fatal("Claude Code not connected along with Kiro Crew")
		}
		if err := a.Disconnect(); err != nil {
			t.Fatal(err)
		}
		if cc.Wired() || !cc.Disconnected() {
			t.Errorf("Claude Code wired %v, the user's disconnect %v", cc.Wired(), cc.Disconnected())
		}
	})
}

// Set to a harness that isn't installed here, Kiro Crew runs on one that
// is connected, as before; with none, it still says to connect one.
func TestKiroCrewHarnessNotHere(t *testing.T) {
	a, cc, _ := kiroCrewOnClaude(t)
	os.RemoveAll(cc.Dir)
	if cc.Detected() {
		t.Skip("Claude Code found here anyway")
	}
	if _, err := a.ConnectHow(); !errors.Is(err, errKiroCrewNoHarness) {
		t.Fatalf("connect: %v", err)
	}
	if cc.Wired() {
		t.Error("Claude Code connected while not installed")
	}
}

// On Windows Kiro Crew's home is under the user's profile the same way,
// its app is found by its venv's kirocrew.exe, and an adapter npm put in
// as a .cmd shim is found where Crew's which finds it.
func TestKiroCrewOnWindows(t *testing.T) {
	was := kiroCrewOS
	t.Cleanup(func() { kiroCrewOS = was })
	kiroCrewOS = "windows"
	home := syncHome(t)
	t.Setenv("KIROCREW_HOME", "")
	t.Setenv("PATH", t.TempDir())
	env := map[string]string{"USERPROFILE": home, "APPDATA": filepath.Join(home, "AppData", "Roaming"), "LOCALAPPDATA": filepath.Join(home, "AppData", "Local")}
	getenv := func(k string) string { return env[k] }
	put := func(p string) {
		t.Helper()
		if err := mkFile(p); err != nil {
			t.Fatal(err)
		}
	}
	a := kiroCrew(home)
	if a.Path != filepath.Join(home, ".kiro", "crew", "config.json") {
		t.Errorf("path %s", a.Path)
	}
	if a.Detected() {
		t.Fatal("detected with nothing here")
	}
	put(filepath.Join(home, ".kirocrew-app", ".venv", "Scripts", "kirocrew.exe"))
	if !a.Detected() {
		t.Error("Kiro Crew's app not detected by its venv's kirocrew.exe")
	}
	cl, _ := kiroCrewHarnessOf("claude")
	if kiroCrewFinds(cl, home, getenv) {
		t.Fatal("found with none")
	}
	put(filepath.Join(home, ".npm-global", "bin", "claude-agent-acp.cmd"))
	if !kiroCrewFinds(cl, home, getenv) {
		t.Error("claude-agent-acp.cmd not found")
	}
}

// setJSONFile sets dotted keys in a JSON file, as a user's editor would.
func setJSONFile(path string, kv map[string]any) error {
	b, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	var m map[string]any
	if err := json.Unmarshal(b, &m); err != nil {
		return err
	}
	for k, v := range kv {
		o := m
		parts := strings.Split(k, ".")
		for _, p := range parts[:len(parts)-1] {
			n, ok := o[p].(map[string]any)
			if !ok {
				n = map[string]any{}
				o[p] = n
			}
			o = n
		}
		o[parts[len(parts)-1]] = v
	}
	out, err := json.MarshalIndent(m, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(path, out, 0o600)
}

// mkFile makes an empty file and its folders.
func mkFile(p string) error {
	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
		return err
	}
	return os.WriteFile(p, nil, 0o755)
}