Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package agent
import (
"encoding/json"
"fmt"
"io/fs"
"os"
"path/filepath"
"reflect"
"runtime"
"strings"
"testing"
"time"
"github.com/yetone/magpie/internal/desktopdir"
"github.com/yetone/magpie/internal/edit"
"github.com/yetone/magpie/internal/gateway"
"github.com/yetone/magpie/internal/provider"
)
// desktopSandbox is a home of its own with nothing of this machine's in
// reach: every variable Desktop's folders (and magpie's stash) follow.
func desktopSandbox(t *testing.T) (string, desktopPaths) {
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("USERPROFILE", home)
t.Setenv("APPDATA", filepath.Join(home, "AppData", "Roaming"))
t.Setenv("LOCALAPPDATA", filepath.Join(home, "AppData", "Local"))
t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
t.Setenv("XDG_CACHE_HOME", filepath.Join(home, ".cache"))
p := desktopPathsOf(desktopDirs(runtime.GOOS, home, os.Getenv))
return home, p
}
// desktopTree is every file (with its bytes) and folder under Desktop's two.
func desktopTree(t *testing.T, p desktopPaths) map[string]string {
out := map[string]string{}
for _, root := range []string{p.dir, p.dir3p} {
filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
if err != nil {
return nil
}
if d.IsDir() {
out[path] = "/"
return nil
}
b, _ := os.ReadFile(path)
out[path] = string(b)
return nil
})
}
return out
}
func desktopJSON(t *testing.T, path string) map[string]any {
t.Helper()
var m map[string]any
b, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(b, &m); err != nil {
t.Fatalf("%s: %v\n%s", path, err, b)
}
return m
}
func desktopWrite(t *testing.T, path, s string) {
t.Helper()
os.MkdirAll(filepath.Dir(path), 0o755)
if err := os.WriteFile(path, []byte(s), 0o644); err != nil {
t.Fatal(err)
}
}
func TestDesktopDirs(t *testing.T) {
env := func(m map[string]string) func(string) string { return func(k string) string { return m[k] } }
home := t.TempDir()
d, d3 := desktopDirs("darwin", home, env(nil))
as := filepath.Join(home, "Library", "Application Support")
if d != filepath.Join(as, "Claude") || d3 != filepath.Join(as, "Claude-3p") {
t.Errorf("darwin: %s %s", d, d3)
}
xdg := filepath.Join(home, "xdg")
if d, d3 = desktopDirs("linux", home, env(map[string]string{"XDG_CONFIG_HOME": xdg})); d != filepath.Join(xdg, "Claude") || d3 != filepath.Join(xdg, "Claude-3p") {
t.Errorf("linux, XDG_CONFIG_HOME: %s %s", d, d3)
}
for _, x := range []string{"", "relative/dir"} {
if d, d3 = desktopDirs("linux", home, env(map[string]string{"XDG_CONFIG_HOME": x})); d != filepath.Join(home, ".config", "Claude") || d3 != filepath.Join(home, ".config", "Claude-3p") {
t.Errorf("linux, XDG_CONFIG_HOME %q: %s %s", x, d, d3)
}
}
// Windows: %LOCALAPPDATA%\Claude and Claude-3p, else ~\AppData\Local
local := filepath.Join(home, "Local")
if d, d3 = desktopDirs("windows", home, env(map[string]string{"LOCALAPPDATA": local})); d != filepath.Join(local, "Claude") || d3 != filepath.Join(local, "Claude-3p") {
t.Errorf("windows: %s %s", d, d3)
}
if d, _ = desktopDirs("windows", home, env(nil)); d != filepath.Join(home, "AppData", "Local", "Claude") {
t.Errorf("windows without LOCALAPPDATA: %s", d)
}
// a folder named otherwise (Claude… with or without -3p) is taken when
// the exact one isn't there, the exact one first when it is
os.MkdirAll(filepath.Join(local, "ClaudeBeta"), 0o755)
os.MkdirAll(filepath.Join(local, "ClaudeBeta-3p"), 0o755)
os.MkdirAll(filepath.Join(local, "claude-cli-nodejs"), 0o755)
if d, d3 = desktopDirs("windows", home, env(map[string]string{"LOCALAPPDATA": local})); d != filepath.Join(local, "ClaudeBeta") || d3 != filepath.Join(local, "ClaudeBeta-3p") {
t.Errorf("windows, other names: %s %s", d, d3)
}
os.MkdirAll(filepath.Join(local, "Claude"), 0o755)
if d, _ = desktopDirs("windows", home, env(map[string]string{"LOCALAPPDATA": local})); d != filepath.Join(local, "Claude") {
t.Errorf("windows, exact: %s", d)
}
}
// A fresh Claude Desktop: its folder and nothing magpie writes in it yet.
func TestClaudeDesktopFresh(t *testing.T) {
home, p := desktopSandbox(t)
a := claudeDesktop(home)
if a.Detected() {
t.Fatal("detected without its folder")
}
os.MkdirAll(p.dir, 0o755)
if !a.Detected() {
t.Fatal("not detected")
}
before := desktopTree(t, p)
f := a.Field("provider")
if f.Get() != "" {
t.Fatalf("get: %q", f.Get())
}
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
for _, c := range []string{p.config, p.config3p} {
if m := desktopJSON(t, c); !reflect.DeepEqual(m, map[string]any{"deploymentMode": "3p"}) {
t.Errorf("%s: %v", c, m)
}
}
want := map[string]any{
"inferenceProvider": "gateway", "inferenceGatewayBaseUrl": gateway.URL(),
"inferenceGatewayApiKey": "magpie-claude-desktop", "inferenceGatewayAuthScheme": "bearer",
"disableDeploymentModeChooser": true, "coworkEgressAllowedHosts": []any{"*"},
"claudeAiImport": map[string]any{"enabled": true, "bannerBehavior": "detect"},
}
if prof := desktopJSON(t, p.prof); !reflect.DeepEqual(prof, want) {
t.Errorf("profile: %v", prof)
}
if st, _ := os.Stat(p.prof); runtime.GOOS != "windows" && st.Mode().Perm() != 0o600 {
t.Errorf("profile mode %v", st.Mode())
}
meta := desktopJSON(t, p.meta)
if meta["appliedId"] != desktopProfileID || !reflect.DeepEqual(meta["entries"], []any{map[string]any{"id": desktopProfileID, "name": "magpie"}}) {
t.Errorf("meta: %v", meta)
}
if f.Get() != "magpie" || a.Check() != "" {
t.Fatalf("get %q, check %q", f.Get(), a.Check())
}
if n := a.Notice(); n == "" {
t.Error("no restart notice")
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if after := desktopTree(t, p); !reflect.DeepEqual(after, before) {
t.Fatalf("off left:\n%v\nwas:\n%v", after, before)
}
if f.Get() != "" {
t.Fatalf("get after off: %q", f.Get())
}
// off again changes nothing
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if after := desktopTree(t, p); !reflect.DeepEqual(after, before) {
t.Fatalf("second off: %v", after)
}
}
// A Desktop with settings and third-party profiles of its own: they are all
// kept, and off puts every byte back.
func TestClaudeDesktopKeepsTheUsers(t *testing.T) {
home, p := desktopSandbox(t)
desktopWrite(t, p.config, "{\n \"globalShortcut\": \"Alt+Space\",\n \"deploymentMode\": \"1p\",\n \"mcpServers\": {\n \"fs\": {\n \"command\": \"npx\"\n }\n }\n}\n")
desktopWrite(t, p.config3p, "{\n \"preferences\": {\n \"theme\": \"dark\"\n }\n}\n")
desktopWrite(t, p.meta, "{\n \"appliedId\": \"mine-2\",\n \"entries\": [\n {\n \"id\": \"mine-1\",\n \"name\": \"Bedrock\"\n },\n {\n \"id\": \"mine-2\",\n \"name\": \"Corp gateway\"\n }\n ]\n}\n")
desktopWrite(t, filepath.Join(p.library, "mine-2.json"), `{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://corp.example"}`)
before := desktopTree(t, p)
a := claudeDesktop(home)
f := a.Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
cfg := desktopJSON(t, p.config)
if cfg["deploymentMode"] != "3p" || cfg["globalShortcut"] != "Alt+Space" || cfg["mcpServers"] == nil {
t.Errorf("config: %v", cfg)
}
if cfg := desktopJSON(t, p.config3p); cfg["deploymentMode"] != "3p" || cfg["preferences"] == nil {
t.Errorf("3p config: %v", cfg)
}
meta := desktopJSON(t, p.meta)
entries, _ := meta["entries"].([]any)
if meta["appliedId"] != desktopProfileID || len(entries) != 3 ||
entries[0].(map[string]any)["id"] != "mine-1" || entries[2].(map[string]any)["id"] != desktopProfileID {
t.Errorf("meta: %v", meta)
}
if b, _ := os.ReadFile(filepath.Join(p.library, "mine-2.json")); string(b) != before[filepath.Join(p.library, "mine-2.json")] {
t.Error("the user's profile was touched")
}
on := desktopTree(t, p)
// on again changes nothing
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
if again := desktopTree(t, p); !reflect.DeepEqual(again, on) {
t.Fatalf("on twice:\n%v\nonce:\n%v", again, on)
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
after := desktopTree(t, p)
for k, v := range before {
if after[k] != v {
t.Errorf("%s after off:\n%s\nwas:\n%s", k, after[k], v)
}
}
if len(after) != len(before) {
t.Errorf("off left %d paths, was %d: %v", len(after), len(before), after)
}
// on → off → on is the first on again
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
if again := desktopTree(t, p); !reflect.DeepEqual(again, on) {
t.Fatalf("on after off:\n%v\nfirst:\n%v", again, on)
}
}
// Desktop or the user changing things after magpie: Check says so, off
// leaves what they chose, and the profile the user's own settings in it.
func TestClaudeDesktopChangedSince(t *testing.T) {
home, p := desktopSandbox(t)
os.MkdirAll(p.dir, 0o755)
desktopWrite(t, p.meta, `{"entries":[{"id":"mine","name":"Mine"}],"appliedId":"mine"}`)
a := claudeDesktop(home)
f := a.Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
// a setting made in Desktop's window stays through a second on
desktopWrite(t, p.prof, `{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"http://elsewhere:1","userAutoMode":true,"coworkEgressAllowedHosts":["corp.example"]}`)
if c := a.Check(); c == "" {
t.Error("check: a profile pointing elsewhere is fine")
}
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
prof := desktopJSON(t, p.prof)
if prof["userAutoMode"] != true || !reflect.DeepEqual(prof["coworkEgressAllowedHosts"], []any{"corp.example"}) ||
prof["inferenceGatewayBaseUrl"] != gateway.URL() || prof["disableDeploymentModeChooser"] != true {
t.Errorf("profile: %v", prof)
}
if c := a.Check(); c != "" {
t.Errorf("check after on: %s", c)
}
desktopWrite(t, p.config, `{"deploymentMode":"1p"}`)
if c := a.Check(); c == "" {
t.Error("check: 1p is fine")
}
// off: the user's 1p stays, their profile is applied again
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if m := desktopJSON(t, p.config); m["deploymentMode"] != "1p" {
t.Errorf("config: %v", m)
}
if _, err := os.Stat(p.config3p); !os.IsNotExist(err) {
t.Error("the 3p config magpie made is still there")
}
if meta := desktopJSON(t, p.meta); meta["appliedId"] != "mine" || len(meta["entries"].([]any)) != 1 {
t.Errorf("meta: %v", meta)
}
if _, err := os.Stat(p.prof); !os.IsNotExist(err) {
t.Error("magpie's profile is still there")
}
}
// #2035 (capiton0): settings the user made in Desktop's third-party window
// live in magpie's profile. Switching Desktop off magpie and on again
// brings them back, the gateway's address and key set anew.
func TestClaudeDesktopOffOnKeepsTheUsersSettings(t *testing.T) {
home, p := desktopSandbox(t)
os.MkdirAll(p.dir, 0o755)
a := claudeDesktop(home)
f := a.Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
desktopWrite(t, p.prof, `{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"http://old:1","inferenceGatewayApiKey":"old","inferenceGatewayAuthScheme":"bearer",`+
`"disableDeploymentModeChooser":false,"coworkEgressAllowedHosts":["corp.example"],"inferenceModels":["claude-opus-4-7"],"isClaudeCodeForDesktopEnabled":true}`)
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(p.prof); !os.IsNotExist(err) {
t.Fatal("magpie's profile is still there after off")
}
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
prof := desktopJSON(t, p.prof)
want := map[string]any{
"inferenceProvider": "gateway", "inferenceGatewayBaseUrl": gateway.URL(),
"inferenceGatewayApiKey": "magpie-claude-desktop", "inferenceGatewayAuthScheme": "bearer",
"disableDeploymentModeChooser": false, "coworkEgressAllowedHosts": []any{"corp.example"},
"inferenceModels": []any{"claude-opus-4-7"}, "isClaudeCodeForDesktopEnabled": true,
}
if !reflect.DeepEqual(prof, want) {
t.Errorf("profile after off and on:\n%v\nwant\n%v", prof, want)
}
if f.Get() != "magpie" || a.Check() != "" {
t.Errorf("get %q, check %q", f.Get(), a.Check())
}
}
// #2035 (capiton0): a profile the user made in Desktop's window for
// magpie's gateway, applied when magpie is switched on, starts magpie's
// profile: their settings (as they posted them) are kept, only the
// gateway's address, key and auth scheme set. Their own profile is left
// as it was and applied again when magpie is switched off.
func TestClaudeDesktopOnKeepsTheUsersOwnGatewayProfile(t *testing.T) {
home, p := desktopSandbox(t)
const theirs = `{
"inferenceGatewayBaseUrl": "` + "%s" + `",
"inferenceGatewayApiKey": "magpie",
"sshHostAllowlist": ["*"],
"chatTabEnabled": true,
"chatAdvancedFileAnalysisEnabled": true,
"isDesktopExtensionEnabled": true,
"modelPrefer1mContext": true,
"defaultModelEffort": "max",
"autoModeEnabled": true,
"toolSearchEnabled": true,
"skipWebFetchPreflight": true,
"coworkEgressAllowedHosts": ["*"],
"disableDeploymentModeChooser": true,
"disableDeepLinkRegistration": true,
"inferenceProvider": "gateway",
"inferenceCredentialKind": "static"
}`
own := filepath.Join(p.library, "5b0d0c6e-1f2a-4c3b-9d4e-0a1b2c3d4e5f.json")
body := fmt.Sprintf(theirs, gateway.URL())
desktopWrite(t, own, body)
desktopWrite(t, p.meta, `{"appliedId":"5b0d0c6e-1f2a-4c3b-9d4e-0a1b2c3d4e5f","entries":[{"id":"5b0d0c6e-1f2a-4c3b-9d4e-0a1b2c3d4e5f","name":"mine"}]}`)
a := claudeDesktop(home)
f := a.Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
var want map[string]any
json.Unmarshal([]byte(body), &want)
want["inferenceGatewayApiKey"] = "magpie-claude-desktop"
want["inferenceGatewayAuthScheme"] = "bearer"
want["claudeAiImport"] = map[string]any{"enabled": true, "bannerBehavior": "detect"}
if prof := desktopJSON(t, p.prof); !reflect.DeepEqual(prof, want) {
t.Errorf("magpie's profile:\n%v\nwant\n%v", prof, want)
}
if b, _ := os.ReadFile(own); string(b) != body {
t.Errorf("their profile was changed:\n%s", b)
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if id, _ := desktopJSON(t, p.meta)["appliedId"].(string); id != "5b0d0c6e-1f2a-4c3b-9d4e-0a1b2c3d4e5f" {
t.Errorf("applied after off: %q", id)
}
if b, _ := os.ReadFile(own); string(b) != body {
t.Errorf("their profile after off:\n%s", b)
}
}
// A profile for somewhere else (another gateway, Bedrock) is not carried
// into magpie's: its models and settings are for that place.
func TestClaudeDesktopOnLeavesOtherProfilesOut(t *testing.T) {
for name, prof := range map[string]string{
"other gateway": `{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"https://llm.example.com","inferenceModels":["corp-model"],"chatTabEnabled":true}`,
"bedrock": `{"inferenceProvider":"bedrock","inferenceBedrockRegion":"us-east-1","chatTabEnabled":true}`,
} {
t.Run(name, func(t *testing.T) {
home, p := desktopSandbox(t)
desktopWrite(t, filepath.Join(p.library, "abc.json"), prof)
desktopWrite(t, p.meta, `{"appliedId":"abc","entries":[{"id":"abc","name":"mine"}]}`)
if err := claudeDesktop(home).Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
got := desktopJSON(t, p.prof)
if _, ok := got["chatTabEnabled"]; ok {
t.Errorf("magpie's profile took another place's settings: %v", got)
}
})
}
}
// A file magpie can't read as Desktop writes it is left alone, and so is
// everything else.
func TestClaudeDesktopRefusesOddFiles(t *testing.T) {
home, p := desktopSandbox(t)
desktopWrite(t, p.meta, `[]`)
if err := claudeDesktop(home).Field("provider").Set("magpie"); err == nil {
t.Fatal("a meta file that isn't an object was taken")
}
if b, _ := os.ReadFile(p.meta); string(b) != "[]" {
t.Errorf("meta: %s", b)
}
for _, f := range []string{p.config, p.config3p, p.prof} {
if _, err := os.Stat(f); err == nil {
t.Errorf("%s written", f)
}
}
desktopWrite(t, p.meta, `{"entries":{}}`)
if err := claudeDesktop(home).Field("provider").Set("magpie"); err == nil {
t.Fatal("entries that aren't a list were taken")
}
}
// each of Claude Code's tiers in Desktop's Code tab can have a model of its
// own (WilianWeng): offered once Desktop is on magpie, set by the catalog id
// or by the id Desktop is shown, and taken away with ""
func TestClaudeDesktopTiers(t *testing.T) {
home, _ := desktopSandbox(t)
if err := provider.Save(provider.Provider{ID: "v", Name: "V", Chat: "http://127.0.0.1:1/v1", Key: "k", Models: []string{"a", "b"}}); err != nil {
t.Fatal(err)
}
a := claudeDesktop(home)
f := a.Field("sonnet")
if f == nil || !f.Quiet {
t.Fatal("no quiet sonnet field")
}
if len(f.Options(nil)) != 0 {
t.Fatal("tiers offered before Desktop is on magpie")
}
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if len(f.Options(nil)) != 2 {
t.Fatalf("options: %+v", f.Options(nil))
}
if err := f.Set("v/a"); err != nil {
t.Fatal(err)
}
if err := a.Field("haiku").Set(gateway.DesktopID(provider.Entry{ID: "v/b"})); err != nil {
t.Fatal(err)
}
if f.Get() != "v/a" || a.Field("haiku").Get() != "v/b" || a.Field("opus").Get() != "" {
t.Fatalf("tiers: %v", gateway.DesktopTiers())
}
if err := f.Set("nope/x"); err == nil {
t.Fatal("a model magpie doesn't serve was taken")
}
if err := f.Set(""); err != nil || f.Get() != "" {
t.Fatalf("unset: %v %q", err, f.Get())
}
}
// Kilig on Discord: Claude Desktop from its setup.exe on Windows 10 LTSC
// runs as an MSIX package, its data in
// %LOCALAPPDATA%\Packages\Claude_<publisher>\LocalCache\Roaming\Claude and
// nothing in %APPDATA%\Claude. It is detected, and magpie's switch writes
// the package's folders, which the packaged app up to 2.x reads. bg5eau on
// X: 2.31226.1, packaged the same way, reads the real
// %LOCALAPPDATA%\Claude-3p, so the switch writes the real folders too, and
// switching off leaves both as they were.
func TestClaudeDesktopMSIX(t *testing.T) {
home, _ := desktopSandbox(t)
old := desktopdir.OS
desktopdir.OS = "windows"
t.Cleanup(func() { desktopdir.OS = old })
local, roaming := filepath.Join(home, "AppData", "Local"), filepath.Join(home, "AppData", "Roaming")
os.MkdirAll(roaming, 0o755)
pkg := filepath.Join(local, "Packages", "Claude_pzs8sxrjxfjjc", "LocalCache")
data := filepath.Join(pkg, "Roaming", "Claude")
for _, d := range []string{"claude-code-sessions", "local-agent-mode-sessions", "Local Storage", "IndexedDB", "logs"} {
os.MkdirAll(filepath.Join(data, d), 0o755)
}
os.WriteFile(filepath.Join(data, "Local State"), []byte(`{}`), 0o644)
os.MkdirAll(filepath.Join(pkg, "Local", "Claude", "logs"), 0o755)
// the newer build's own 3p folder: its settings, which stay
desktopWrite(t, filepath.Join(local, "Claude-3p", "claude_desktop_config.json"), `{"preferences":{"x":1}}`)
p := desktopPathsOf(filepath.Join(pkg, "Local", "Claude"), filepath.Join(pkg, "Local", "Claude-3p"))
r := desktopPathsOf(filepath.Join(local, "Claude"), filepath.Join(local, "Claude-3p"))
before, beforeReal := desktopTree(t, p), desktopTree(t, r)
a := claudeDesktop(home)
if !a.Detected() {
t.Fatal("an MSIX Claude Desktop isn't detected")
}
if want := filepath.Join(pkg, "Local", "Claude", "claude_desktop_config.json"); a.Path != want {
t.Errorf("path %s, want %s", a.Path, want)
}
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if a.Field("provider").Get() != magpieID {
t.Fatal("not on magpie")
}
for _, q := range []desktopPaths{p, r} {
if !desktopWired(q) {
t.Fatalf("not wired in %s: %v", q.dir3p, desktopTree(t, q))
}
for _, f := range []string{q.config, q.config3p} {
if m := desktopJSON(t, f); m["deploymentMode"] != "3p" {
t.Errorf("%s: %v", f, m)
}
}
if m := desktopJSON(t, q.prof); m["inferenceGatewayBaseUrl"] != gateway.URL() || m["inferenceGatewayAuthScheme"] != "bearer" {
t.Errorf("%s: %v", q.prof, m)
}
if m := desktopJSON(t, q.meta); m["appliedId"] != desktopProfileID {
t.Errorf("%s: %v", q.meta, m)
}
}
if m := desktopJSON(t, r.config3p); m["preferences"] == nil {
t.Errorf("the real Claude-3p's own settings lost: %v", m)
}
if c := a.Check(); c != "" {
t.Errorf("check: %s", c)
}
// Desktop's chooser turns the real one back to 1p: the check says so
desktopWrite(t, r.config3p, `{"deploymentMode":"1p","preferences":{"x":1}}`)
if c := a.Check(); !strings.Contains(c, "no longer 3p") || !strings.Contains(c, r.dir3p) {
t.Errorf("check: %q", c)
}
desktopWrite(t, r.config3p, `{"deploymentMode":"3p","preferences":{"x":1}}`)
if err := a.Field("provider").Set(""); err != nil {
t.Fatal(err)
}
if got := desktopTree(t, p); !reflect.DeepEqual(got, before) {
t.Errorf("package's folders not as they were:\n got %v\nwant %v", got, before)
}
if got := desktopTree(t, r); !reflect.DeepEqual(got, beforeReal) {
t.Errorf("real folders not as they were:\n got %v\nwant %v", got, beforeReal)
}
}
// A packaged Desktop switched on by a magpie that wrote only the
// package's folders keeps its stash: switching on now writes the real ones
// too, and off still leaves the package's as they were before magpie.
func TestClaudeDesktopMSIXStashBefore(t *testing.T) {
home, _ := desktopSandbox(t)
old := desktopdir.OS
desktopdir.OS = "windows"
t.Cleanup(func() { desktopdir.OS = old })
local := filepath.Join(home, "AppData", "Local")
pkg := filepath.Join(local, "Packages", "Claude_pzs8sxrjxfjjc", "LocalCache")
desktopWrite(t, filepath.Join(pkg, "Roaming", "Claude", "Local State"), `{}`)
p := desktopPathsOf(filepath.Join(pkg, "Local", "Claude"), filepath.Join(pkg, "Local", "Claude-3p"))
desktopWrite(t, p.config3p, `{"deploymentMode":"1p"}`)
before := desktopTree(t, p)
// as the magpie before wrote it: the package's set, the plain keys
if err := desktopOn(p); err != nil {
t.Fatal(err)
}
r := desktopPathsOf(filepath.Join(local, "Claude"), filepath.Join(local, "Claude-3p"))
a := claudeDesktop(home)
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if !desktopWired(r) {
t.Fatal("real folders not written")
}
if err := a.Field("provider").Set(""); err != nil {
t.Fatal(err)
}
if got := desktopTree(t, p); !reflect.DeepEqual(got, before) {
t.Errorf("package's folders not as they were:\n got %v\nwant %v", got, before)
}
for _, d := range []string{r.dir, r.dir3p} {
if _, err := os.Stat(d); err == nil {
t.Errorf("%s left behind", d)
}
}
}
// dumplings on Discord: Desktop 2.31226.0 from its MSIX on Windows runs in
// the real %LOCALAPPDATA%\Claude-3p (its "Local State" there is the newest),
// and the package's LocalCache copy, which magpie wrote too, is emptied.
// Desktop is on magpie and the card doesn't say it was changed; the copy
// Desktop reads turned back to 1p still does, and Reconnect with a tier on
// one of magpie's models puts the gateway back, not only the tier.
func TestClaudeDesktopMSIXChecksTheFoldersDesktopRuns(t *testing.T) {
home, _ := desktopSandbox(t)
old := desktopdir.OS
desktopdir.OS = "windows"
t.Cleanup(func() { desktopdir.OS = old })
if err := provider.Save(provider.Provider{ID: "v", Name: "V", Chat: "http://127.0.0.1:1/v1", Key: "k", Models: []string{"a", "b"}}); err != nil {
t.Fatal(err)
}
local := filepath.Join(home, "AppData", "Local")
os.MkdirAll(filepath.Join(home, "AppData", "Roaming"), 0o755)
pkg := filepath.Join(local, "Packages", "Claude_pzs8sxrjxfjjc", "LocalCache")
pkg3p, real3p := filepath.Join(pkg, "Local", "Claude-3p"), filepath.Join(local, "Claude-3p")
desktopWrite(t, filepath.Join(pkg, "Roaming", "Claude", "Local State"), `{}`)
desktopWrite(t, filepath.Join(pkg3p, "Local State"), `{}`)
desktopWrite(t, filepath.Join(real3p, "Local State"), `{}`)
desktopWrite(t, filepath.Join(real3p, "claude_desktop_config.json"), `{"preferences":{"x":1}}`)
then := time.Now().Add(-48 * time.Hour)
for _, f := range []string{filepath.Join(pkg, "Roaming", "Claude", "Local State"), filepath.Join(pkg3p, "Local State")} {
os.Chtimes(f, then, then)
}
a := claudeDesktop(home)
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if err := a.Field("sonnet").Set("v/a"); err != nil {
t.Fatal(err)
}
if c := a.Check(); c != "" {
t.Fatalf("check: %s", c)
}
// the update leaves the package's Claude-3p empty
if err := os.RemoveAll(pkg3p); err != nil {
t.Fatal(err)
}
os.MkdirAll(pkg3p, 0o755)
if c := a.Check(); c != "" {
t.Errorf("the package's copy Desktop no longer reads: %s", c)
}
if d := a.Drift(); d != nil && d.Kind == "unwired" {
t.Errorf("drift: %+v", d)
}
// the one Desktop runs in, turned back to 1p, is said
r := desktopPathsOf(filepath.Join(local, "Claude"), real3p)
desktopWrite(t, r.config3p, `{"deploymentMode":"1p","preferences":{"x":1}}`)
if c := a.Check(); !strings.Contains(c, "no longer 3p") || !strings.Contains(c, real3p) {
t.Fatalf("check: %q", c)
}
if d := a.Drift(); d == nil || d.Kind != "unwired" {
t.Fatalf("drift: %+v", d)
}
// Reconnect: the gateway back, with the tier
if err := a.Reapply(); err != nil {
t.Fatal(err)
}
if c := a.Check(); c != "" {
t.Errorf("after Reconnect: %s", c)
}
if m := desktopJSON(t, r.config3p); m["deploymentMode"] != "3p" || m["preferences"] == nil {
t.Errorf("%s: %v", r.config3p, m)
}
if got := a.Field("sonnet").Get(); got != "v/a" {
t.Errorf("sonnet: %q", got)
}
}
// Claude-3p is a userData of its own, so Desktop on magpie started in the
// system's language, not the one picked signed in with Anthropic (memory
// and Osal on Discord: Chinese gone). The language is carried into
// Claude-3p's config.json, nothing else of Claude's is, and off takes the
// file magpie made for it away again.
func TestClaudeDesktopCarriesTheLanguage(t *testing.T) {
home, p := desktopSandbox(t)
own := "{\n \"locale\": \"zh-CN\",\n \"userThemeMode\": \"dark\"\n}\n"
desktopWrite(t, p.app, own)
before := desktopTree(t, p)
f := claudeDesktop(home).Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
if m := desktopJSON(t, p.app3p); !reflect.DeepEqual(m, map[string]any{"locale": "zh-CN"}) {
t.Errorf("Claude-3p's config.json: %v", m)
}
if b, _ := os.ReadFile(p.app); string(b) != own {
t.Errorf("Claude's config.json changed:\n%s", b)
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if after := desktopTree(t, p); !reflect.DeepEqual(after, before) {
t.Fatalf("off left:\n%v\nwas:\n%v", after, before)
}
}
// A language already set in 3p mode (Desktop's, or the user's by hand) is
// theirs: no write of magpie's changes Claude-3p's config.json, on, again,
// off and on again, and off leaves it there.
func TestClaudeDesktopKeepsThe3pLanguage(t *testing.T) {
home, p := desktopSandbox(t)
desktopWrite(t, p.app, `{"locale":"zh-CN"}`)
mine := "{\n \"locale\": \"ja-JP\",\n \"windowBounds\": {\n \"width\": 900\n }\n}\n"
desktopWrite(t, p.app3p, mine)
f := claudeDesktop(home).Field("provider")
for i, v := range []string{"magpie", "magpie", "", "magpie"} {
if err := f.Set(v); err != nil {
t.Fatal(err)
}
if b, _ := os.ReadFile(p.app3p); string(b) != mine {
t.Fatalf("step %d (%q): Claude-3p's config.json is now\n%s", i, v, b)
}
}
}
// Wired, and Desktop has written its config.json since: the user then
// sets the language there by hand. Applying magpie again keeps every key;
// off keeps the file, which is no longer magpie's alone.
func TestClaudeDesktopUserEditsThenReapply(t *testing.T) {
home, p := desktopSandbox(t)
f := claudeDesktop(home).Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(p.app3p); err == nil {
t.Fatal("config.json written with no language to carry")
}
desktopWrite(t, p.app, `{"locale":"zh-CN"}`)
edited := "{\n \"locale\": \"zh-TW\",\n \"hasCompletedOnboarding\": true\n}\n"
desktopWrite(t, p.app3p, edited)
for _, v := range []string{"magpie", "", "magpie"} {
if err := f.Set(v); err != nil {
t.Fatal(err)
}
if b, _ := os.ReadFile(p.app3p); string(b) != edited {
t.Fatalf("%q: the user's edit is gone:\n%s", v, b)
}
}
}
// Only a language Desktop can name is carried, and a Claude-3p config.json
// magpie can't read as an object is left as it is, the takeover going on.
func TestClaudeDesktopLanguageOddValues(t *testing.T) {
for _, own := range []string{`{"locale":"../../x"}`, `{"locale":7}`, `{"locale":""}`, `not json`} {
home, p := desktopSandbox(t)
desktopWrite(t, p.app, own)
if err := claudeDesktop(home).Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if b, err := os.ReadFile(p.app3p); err == nil {
t.Errorf("%s: carried %s", own, b)
}
}
home, p := desktopSandbox(t)
desktopWrite(t, p.app, `{"locale":"zh-CN"}`)
desktopWrite(t, p.app3p, `[1]`)
if err := claudeDesktop(home).Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if b, _ := os.ReadFile(p.app3p); string(b) != `[1]` {
t.Errorf("odd config.json written: %s", b)
}
if m := desktopJSON(t, p.config3p); m["deploymentMode"] != "3p" {
t.Errorf("takeover stopped: %v", m)
}
}
// lambdua on X: Desktop on magpie runs in Claude-3p, a userData of its own,
// so the Code and Cowork sessions it had signed in with Anthropic were out
// of sight. Desktop imports them itself (Settings → Import) once its
// claudeAiImport policy is on: magpie's profile gets it, once, on a switch
// on and, for a Desktop already on magpie, from Sync at the next start.
// A claudeAiImport the user has, or took away since, stays theirs, and
// Desktop's own sessions are never touched.
func TestClaudeDesktopOffersItsSessionImport(t *testing.T) {
home, p := desktopSandbox(t)
on := map[string]any{"enabled": true, "bannerBehavior": "detect"}
// a session Desktop wrote signed in with Anthropic
session := filepath.Join(p.dir, "claude-code-sessions", "acct", "org", "local_1.json")
desktopWrite(t, session, `{"sessionId":"local_1","title":"mine"}`)
a := claudeDesktop(home)
if a.Sync == nil {
t.Fatal("no Sync: a Desktop already on magpie never gets the import")
}
// not on magpie: Sync writes nothing
before := desktopTree(t, p)
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if after := desktopTree(t, p); !reflect.DeepEqual(after, before) {
t.Fatalf("Sync off magpie wrote:\n%v", after)
}
// on magpie before this change: a profile with no claudeAiImport and
// nothing in the stash; Sync seeds it
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if got := desktopJSON(t, p.prof)["claudeAiImport"]; !reflect.DeepEqual(got, on) {
t.Fatalf("switch on: claudeAiImport %v", got)
}
prof := desktopJSON(t, p.prof)
delete(prof, "claudeAiImport")
b, _ := json.Marshal(prof)
desktopWrite(t, p.prof, string(b))
forget(desktopImport + p.key)
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if got := desktopJSON(t, p.prof)["claudeAiImport"]; !reflect.DeepEqual(got, on) {
t.Fatalf("Sync on magpie: claudeAiImport %v", got)
}
// the user turns it off in Desktop's window (the key gone): stays off
desktopWrite(t, p.prof, string(b))
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if _, has := desktopJSON(t, p.prof)["claudeAiImport"]; has {
t.Fatal("seeded again over the user's choice")
}
// a claudeAiImport of the user's own, seen first: kept as it is
if err := a.Field("provider").Set(""); err != nil {
t.Fatal(err)
}
forget(desktopImport+p.key, desktopProfile+p.key)
theirs := map[string]any{"enabled": false}
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if err := edit.SetJSON(p.prof, edit.KV{Path: "claudeAiImport", Value: theirs}); err != nil {
t.Fatal(err)
}
forget(desktopImport + p.key)
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if got := desktopJSON(t, p.prof)["claudeAiImport"]; !reflect.DeepEqual(got, theirs) {
t.Fatalf("the user's claudeAiImport: %v", got)
}
// Desktop's own sessions are where they were, as they were
if got, _ := os.ReadFile(session); string(got) != `{"sessionId":"local_1","title":"mine"}` {
t.Fatalf("session: %q", got)
}
}
// aa86222 on Discord: Desktop on magpie had none of the user's connectors.
// 3p mode reads its MCP servers from Claude-3p's claude_desktop_config.json,
// so the ones added signed in with Anthropic (Claude's file) were out of
// sight. Switching on copies each one Claude-3p doesn't have; one of the
// same name there stays theirs; Claude's file is never written; off takes
// the copies back and leaves the tree as it was.
func TestClaudeDesktopCarriesTheMCPServers(t *testing.T) {
home, p := desktopSandbox(t)
own := `{"mcpServers":{"fs":{"command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","/tmp"]},"notes":{"command":"notes-mcp"}}}`
desktopWrite(t, p.config, own)
before := desktopTree(t, p)
a := claudeDesktop(home)
f := a.Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
m := desktopJSON(t, p.config3p)
want := desktopJSON(t, p.config)["mcpServers"]
if !reflect.DeepEqual(m["mcpServers"], want) {
t.Fatalf("Claude-3p's mcpServers: %v, want %v", m["mcpServers"], want)
}
if b, _ := os.ReadFile(p.config); !strings.Contains(string(b), `"notes":{"command":"notes-mcp"}`) {
t.Fatalf("Claude's servers changed:\n%s", b)
}
// on again and Sync: nothing doubled, nothing more written
once := desktopTree(t, p)
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if again := desktopTree(t, p); !reflect.DeepEqual(again, once) {
t.Fatalf("on again changed:\n%v\nwas:\n%v", again, once)
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
if after := desktopTree(t, p); !reflect.DeepEqual(after, before) {
t.Fatalf("off left:\n%v\nwas:\n%v", after, before)
}
}
// A server Claude-3p has already, by the same name, is the user's (or the
// library's) and stays; one the user changed in 3p mode since it was
// copied is theirs and outlives off; Claude-3p's other servers stay.
func TestClaudeDesktopMCPKeepsThe3pServers(t *testing.T) {
home, p := desktopSandbox(t)
desktopWrite(t, p.config, `{"mcpServers":{"a":{"command":"a"},"b":{"command":"b-signed-in"},"c":{"command":"c"}}}`)
desktopWrite(t, p.config3p, `{"mcpServers":{"b":{"command":"b-3p"},"x":{"command":"x"}}}`)
f := claudeDesktop(home).Field("provider")
if err := f.Set("magpie"); err != nil {
t.Fatal(err)
}
got := desktopJSON(t, p.config3p)["mcpServers"]
want := map[string]any{"a": map[string]any{"command": "a"}, "b": map[string]any{"command": "b-3p"},
"c": map[string]any{"command": "c"}, "x": map[string]any{"command": "x"}}
if !reflect.DeepEqual(got, want) {
t.Fatalf("on: %v", got)
}
// the user changes c in 3p mode
if err := edit.SetJSON(p.config3p, edit.KV{Path: "mcpServers.c.command", Value: "c-mine"}); err != nil {
t.Fatal(err)
}
if err := f.Set(""); err != nil {
t.Fatal(err)
}
m := desktopJSON(t, p.config3p)
got = m["mcpServers"]
want = map[string]any{"b": map[string]any{"command": "b-3p"}, "c": map[string]any{"command": "c-mine"}, "x": map[string]any{"command": "x"}}
if !reflect.DeepEqual(got, want) {
t.Fatalf("off: %v", got)
}
if _, has := m["deploymentMode"]; has {
t.Fatalf("off kept the mode: %v", m)
}
}
// A Desktop on magpie from before the servers were carried gets them from
// Sync at magpie's next start, once: a server the user then takes out in
// 3p mode isn't brought back by the next Sync.
func TestClaudeDesktopSyncCarriesTheMCPServersOnce(t *testing.T) {
home, p := desktopSandbox(t)
a := claudeDesktop(home)
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
forget(desktopMCPSeen + p.key)
if err := edit.SetJSON(p.config, edit.KV{Path: "mcpServers", Value: map[string]any{"fs": map[string]any{"command": "fs"}}}); err != nil {
t.Fatal(err)
}
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if got := desktopJSON(t, p.config3p)["mcpServers"]; !reflect.DeepEqual(got, map[string]any{"fs": map[string]any{"command": "fs"}}) {
t.Fatalf("Sync: %v", got)
}
if err := edit.DelJSON(p.config3p, "mcpServers"); err != nil {
t.Fatal(err)
}
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if _, has := desktopJSON(t, p.config3p)["mcpServers"]; has {
t.Fatal("Sync brought back a server the user took out")
}
}
// aa86222 on Discord: Desktop's configuration exported on one computer
// (magpie's profile, with the connectors the user added) and imported on
// another is a new configLibrary entry under an id Desktop makes, applied
// beside magpie's own and CC Switch's. It points at this magpie's
// gateway, so Desktop runs on magpie: the row reads connected, and
// Reconnect keeps it applied and its connectors as they are.
func TestClaudeDesktopImportedProfileIsOnMagpie(t *testing.T) {
const imported = "3f6c2a8e-9b1d-4e57-a0c4-7d2e5f81b9a6"
const ccswitch = "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f"
theirs := func(key string) string {
return `{
"inferenceProvider": "gateway",
"inferenceGatewayBaseUrl": "` + gateway.URL() + `",
"inferenceGatewayApiKey": "` + key + `",
"inferenceGatewayAuthScheme": "bearer",
"disableDeploymentModeChooser": true,
"coworkEgressAllowedHosts": ["*"],
"claudeAiImport": {"enabled": true, "bannerBehavior": "detect"},
"managedMcpServers": [
{"name": "linear", "url": "https://mcp.linear.app/mcp", "transport": "http"},
{"name": "notion", "url": "https://mcp.notion.com/mcp", "transport": "http"}
]
}`
}
setup := func(t *testing.T, key string) (*Agent, desktopPaths, string) {
home, p := desktopSandbox(t)
os.MkdirAll(p.dir, 0o755)
a := claudeDesktop(home)
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
// what Desktop wrote: CC Switch's profile and the imported one,
// the imported one applied
desktopWrite(t, filepath.Join(p.library, ccswitch+".json"),
`{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"http://127.0.0.1:15721/claude-desktop","inferenceGatewayApiKey":"cc-switch"}`)
f := filepath.Join(p.library, imported+".json")
desktopWrite(t, f, theirs(key))
desktopWrite(t, p.meta, `{"appliedId":"`+imported+`","entries":[{"id":"`+ccswitch+`","name":"CC Switch"},`+
`{"id":"`+desktopProfileID+`","name":"magpie"},{"id":"`+imported+`","name":"magpie"}]}`)
return a, p, f
}
applied := func(t *testing.T, p desktopPaths) string {
id, _ := desktopJSON(t, p.meta)["appliedId"].(string)
return id
}
t.Run("this magpie's key", func(t *testing.T) {
a, p, f := setup(t, agentKey("claude-desktop"))
if c := a.Check(); c != "" {
t.Errorf("check: %s", c)
}
if err := a.Sync(); err != nil {
t.Fatal(err)
}
// Reconnect: nothing of theirs changes, theirs stays applied
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if b, _ := os.ReadFile(f); string(b) != theirs(agentKey("claude-desktop")) {
t.Errorf("the imported profile was changed:\n%s", b)
}
if id := applied(t, p); id != imported {
t.Errorf("applied after reconnect: %q", id)
}
if c := a.Check(); c != "" {
t.Errorf("check after reconnect: %s", c)
}
// off: theirs stays applied and as it was
if err := a.Field("provider").Set(""); err != nil {
t.Fatal(err)
}
if id := applied(t, p); id != imported {
t.Errorf("applied after off: %q", id)
}
if b, _ := os.ReadFile(f); string(b) != theirs(agentKey("claude-desktop")) {
t.Errorf("the imported profile after off:\n%s", b)
}
})
t.Run("another magpie's key", func(t *testing.T) {
a, p, f := setup(t, "mk-from-the-other-computer")
if c := a.Check(); c == "" {
t.Error("check: a key the gateway refuses is fine")
}
// magpie's start gives it a key the gateway takes, and nothing else
if err := a.Sync(); err != nil {
t.Fatal(err)
}
var want map[string]any
json.Unmarshal([]byte(theirs(agentKey("claude-desktop"))), &want)
if got := desktopJSON(t, f); !reflect.DeepEqual(got, want) {
t.Errorf("imported profile after sync:\n%v\nwant\n%v", got, want)
}
if c := a.Check(); c != "" {
t.Errorf("check after sync: %s", c)
}
if id := applied(t, p); id != imported {
t.Errorf("applied after sync: %q", id)
}
})
t.Run("reconnect fixes the key", func(t *testing.T) {
a, p, f := setup(t, "mk-from-the-other-computer")
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
var want map[string]any
json.Unmarshal([]byte(theirs(agentKey("claude-desktop"))), &want)
if got := desktopJSON(t, f); !reflect.DeepEqual(got, want) {
t.Errorf("imported profile after reconnect:\n%v\nwant\n%v", got, want)
}
if id := applied(t, p); id != imported || a.Check() != "" {
t.Errorf("applied %q, check %q", id, a.Check())
}
})
t.Run("CC Switch applied", func(t *testing.T) {
a, p, _ := setup(t, agentKey("claude-desktop"))
edit.SetJSON(p.meta, edit.KV{Path: "appliedId", Value: ccswitch})
if c := a.Check(); c == "" {
t.Error("check: CC Switch's profile reads as magpie's")
}
if err := a.Sync(); err != nil {
t.Fatal(err)
}
if got := desktopJSON(t, filepath.Join(p.library, ccswitch+".json")); got["inferenceGatewayApiKey"] != "cc-switch" {
t.Errorf("CC Switch's profile was written: %v", got)
}
// Reconnect applies magpie's own, as before
if err := a.Field("provider").Set("magpie"); err != nil {
t.Fatal(err)
}
if id := applied(t, p); id != desktopProfileID {
t.Errorf("applied after reconnect: %q", id)
}
})
}