From f6c78c9f3b77e32235650fa7693d2092545a2ebb Mon Sep 17 00:00:00 2001 From: Ruslan Strazhnyk Date: Sat, 14 Nov 2026 21:37:19 +0100 Subject: [PATCH] codex: preserve other MCP servers when writing config Replace line matching in the Codex config writer with TOML parsing so qmax-code only replaces its own [mcp_servers.qmax] table and keeps every other server, setting, and comment byte-for-byte. - Detect quoted (`[mcp_servers."qmax"]`) and commented headers; ignore table-like text inside multiline strings. - Refuse to write invalid TOML, unreadable files, or inline/dotted qmax definitions instead of risking unrelated settings. - Write atomically with owner-only permissions; follow an existing symlink rather than replacing it. - Error messages never include configuration values. - Setup detection shares the same parser. --- go.mod | 1 + go.sum | 2 + internal/agent/codex_config.go | 124 +++++++++++++++++------ internal/agent/codex_config_test.go | 146 ++++++++++++++++++++++++++++ internal/agent/setup_orch_test.go | 14 ++- internal/setup/orch.go | 10 +- internal/setup/orch_test.go | 24 +++++ 7 files changed, 276 insertions(+), 45 deletions(-) create mode 100644 internal/agent/codex_config_test.go diff --git a/go.mod b/go.mod index 90425ef..3acdf3f 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/chzyer/readline v1.5.1 github.com/coder/websocket v1.8.15 github.com/getsentry/sentry-go v0.49.0 + github.com/pelletier/go-toml/v2 v2.2.4 golang.org/x/sys v0.47.0 golang.org/x/term v0.45.0 ) diff --git a/go.sum b/go.sum index 0dece96..5b4662e 100644 --- a/go.sum +++ b/go.sum @@ -79,6 +79,8 @@ github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= +github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= +github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= diff --git a/internal/agent/codex_config.go b/internal/agent/codex_config.go index 3fb9899..c3d180a 100644 --- a/internal/agent/codex_config.go +++ b/internal/agent/codex_config.go @@ -1,10 +1,16 @@ package agent import ( + "bytes" + "errors" "fmt" "os" + "path/filepath" "sort" "strings" + + "github.com/pelletier/go-toml/v2" + "github.com/pelletier/go-toml/v2/unstable" ) // QmaxMCPCommand is the binary name written into the Codex MCP config so the @@ -18,52 +24,106 @@ const QmaxMCPCommand = "qmax-code" // returned alreadyHad flag tells the caller whether an entry was already // present (used by setup orchestration to phrase its progress message). func WriteCodexMCPEntry(path string, env map[string]string) (alreadyHad bool, err error) { - data, _ := os.ReadFile(path) - alreadyHad = codexMCPEntryExists(string(data)) - updated := upsertCodexMCPEntry(string(data), QmaxMCPCommand, env) - - if err := os.WriteFile(path, []byte(updated), 0600); err != nil { + // Preserve a user-managed symlink rather than replacing the link itself. + if info, statErr := os.Lstat(path); statErr == nil && info.Mode()&os.ModeSymlink != 0 { + resolved, resolveErr := filepath.EvalSymlinks(path) + if resolveErr != nil { + return false, errors.New("cannot resolve Codex config symlink") + } + path = resolved + } + data, err := os.ReadFile(path) + if err != nil && !errors.Is(err, os.ErrNotExist) { + return false, errors.New("cannot read Codex config; existing settings were not changed") + } + alreadyHad = CodexMCPEntryExists(string(data)) + updated, err := upsertCodexMCPEntry(string(data), QmaxMCPCommand, env) + if err != nil { return alreadyHad, err } + // Replace atomically so a failed write cannot truncate other MCP entries. + f, err := os.CreateTemp(filepath.Dir(path), ".qmax-codex-*") + if err != nil { + return alreadyHad, errors.New("cannot prepare Codex config update") + } + defer func() { _ = os.Remove(f.Name()) }() + if _, err = f.WriteString(updated); err != nil { + _ = f.Close() + return alreadyHad, errors.New("cannot write Codex config update") + } + if err = f.Close(); err != nil { + return alreadyHad, errors.New("cannot close Codex config update") + } + if err = os.Rename(f.Name(), path); err != nil { + return alreadyHad, errors.New("cannot replace Codex config") + } return alreadyHad, nil } -func codexMCPEntryExists(config string) bool { - for _, line := range strings.Split(config, "\n") { - if strings.TrimSpace(line) == "[mcp_servers.qmax]" { - return true - } +// CodexMCPEntryExists reports whether valid TOML defines a qmax MCP entry. +func CodexMCPEntryExists(config string) bool { + var doc struct { + Servers map[string]any `toml:"mcp_servers"` + } + if toml.Unmarshal([]byte(config), &doc) != nil { + return false } - return false + _, ok := doc.Servers["qmax"] + return ok } -func upsertCodexMCPEntry(config, command string, env map[string]string) string { - lines := strings.Split(strings.ReplaceAll(config, "\r\n", "\n"), "\n") - out := make([]string, 0, len(lines)+8) - - for i := 0; i < len(lines); i++ { - if strings.TrimSpace(lines[i]) != "[mcp_servers.qmax]" { - out = append(out, lines[i]) +func upsertCodexMCPEntry(config, command string, env map[string]string) (string, error) { + data := []byte(config) + var doc map[string]any + // Parser diagnostics can contain configuration values. Never return them. + if toml.Unmarshal(data, &doc) != nil { + return "", errors.New("invalid Codex TOML; existing settings were not changed") + } + var parser unstable.Parser + parser.Reset(data) + var out bytes.Buffer + start, skip := 0, false + for parser.NextExpression() { + node := parser.Expression() + if node.Kind != unstable.Table && node.Kind != unstable.ArrayTable { continue } - for i+1 < len(lines) && !isTOMLTableHeader(lines[i+1]) { - i++ + keys := node.Key() + var path []string + offset := 0 + for keys.Next() { + key := keys.Node() + if len(path) == 0 { + offset = int(key.Raw.Offset) + } + path = append(path, string(key.Data)) + } + // The key's source offset handles quoted names and headers with comments; + // unlike line matching it cannot mistake multiline string data for a table. + offset = bytes.LastIndexByte(data[:offset], '\n') + 1 + if !skip { + out.Write(data[start:offset]) } + start = offset + skip = len(path) >= 2 && path[0] == "mcp_servers" && path[1] == "qmax" } - - for len(out) > 0 && strings.TrimSpace(out[len(out)-1]) == "" { - out = out[:len(out)-1] + if parser.Error() != nil { + return "", errors.New("cannot parse Codex config") } - if len(out) > 0 { - out = append(out, "") + if !skip { + out.Write(data[start:]) } - out = append(out, renderCodexMCPEntry(command, env)...) - return strings.Join(out, "\n") + "\n" -} - -func isTOMLTableHeader(line string) bool { - trimmed := strings.TrimSpace(line) - return strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]") + if out.Len() > 0 && out.Bytes()[out.Len()-1] != '\n' { + out.WriteByte('\n') + } + out.WriteString(strings.Join(renderCodexMCPEntry(command, env), "\n") + "\n") + updated := out.String() + // Inline/dotted qmax definitions cannot be safely removed as table ranges. + // Refuse the update rather than duplicate or rewrite unrelated settings. + if toml.Unmarshal([]byte(updated), &doc) != nil { + return "", errors.New("unsupported qmax TOML layout; use a separate [mcp_servers.qmax] table") + } + return updated, nil } func renderCodexMCPEntry(command string, env map[string]string) []string { diff --git a/internal/agent/codex_config_test.go b/internal/agent/codex_config_test.go new file mode 100644 index 0000000..da4fc76 --- /dev/null +++ b/internal/agent/codex_config_test.go @@ -0,0 +1,146 @@ +package agent + +import ( + "os" + "path/filepath" + "reflect" + "strings" + "testing" + + "github.com/pelletier/go-toml/v2" +) + +func TestCodexMCPPreservesOtherSettings(t *testing.T) { + for _, header := range []string{"[mcp_servers.qmax]", `[mcp_servers."qmax"] # local`, `[ 'mcp_servers' . 'qmax' ]`} { + t.Run(header, func(t *testing.T) { + prefix := "model = 'gpt-6-astra'\napproval_policy = 'on-request'\n" + other := `[mcp_servers.remote] # user-owned +url = "https://mcp.example.com/connect" +enabled = false +default_tools_approval_mode = "prompt" +[mcp_servers.local] +command = "other-mcp" +args = ["serve"] +[projects."/tmp/project"] +trust_level = "trusted" +notes = ''' +[mcp_servers.qmax] +this is text, not a table +''' +` + input := prefix + header + "\ncommand = 'old'\n[mcp_servers.qmax.env]\nQMAX_PROJECT_ID = '7'\n" + other + got, err := upsertCodexMCPEntry(input, "qmax-code", map[string]string{"QMAX_PROJECT_ID": "42"}) + if err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(got, prefix) || !strings.Contains(got, other) { + t.Fatal("unrelated config bytes changed") + } + var before, after map[string]any + if err := toml.Unmarshal([]byte(input), &before); err != nil { + t.Fatal(err) + } + if err := toml.Unmarshal([]byte(got), &after); err != nil { + t.Fatal(err) + } + delete(before["mcp_servers"].(map[string]any), "qmax") + servers := after["mcp_servers"].(map[string]any) + qmax := servers["qmax"].(map[string]any) + if qmax["command"] != "qmax-code" || qmax["env"].(map[string]any)["QMAX_PROJECT_ID"] != "42" { + t.Fatal("qmax replacement incorrect") + } + delete(servers, "qmax") + if !reflect.DeepEqual(before, after) { + t.Fatal("unrelated settings changed") + } + if !CodexMCPEntryExists(input) { + t.Fatal("quoted qmax table not detected") + } + }) + } +} + +func TestWriteCodexMCPEntryRejectsInvalidOrUnsupportedConfig(t *testing.T) { + for _, input := range []string{"invalid = [", `mcp_servers = { qmax = { command = "old" } }`} { + t.Run(input, func(t *testing.T) { + path := filepath.Join(t.TempDir(), "config.toml") + if err := os.WriteFile(path, []byte(input), 0600); err != nil { + t.Fatal(err) + } + if _, err := WriteCodexMCPEntry(path, nil); err == nil { + t.Fatal("expected failure") + } + got, err := os.ReadFile(path) + if err != nil || string(got) != input { + t.Fatal("failed update changed original") + } + }) + } +} + +func TestWriteCodexMCPEntryReadFailure(t *testing.T) { + // A directory deterministically fails ReadFile even when tests run as root. + path := t.TempDir() + if _, err := WriteCodexMCPEntry(path, nil); err == nil { + t.Fatal("read failure ignored") + } +} + +func TestWriteCodexMCPEntryAtomicReplacement(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "config.toml") + if err := os.WriteFile(path, []byte("model = 'gpt-6-astra'\n"), 0644); err != nil { + t.Fatal(err) + } + for i := 0; i < 2; i++ { + had, err := WriteCodexMCPEntry(path, nil) + if err != nil || had != (i == 1) { + t.Fatalf("update %d: had=%v err=%v", i, had, err) + } + } + info, err := os.Stat(path) + if err != nil { + t.Fatal(err) + } + if info.Mode().Perm() != 0600 { + t.Fatal("config is not owner-only") + } + entries, err := os.ReadDir(dir) + if err != nil || len(entries) != 1 { + t.Fatal("temporary file left behind") + } +} + +func TestWriteCodexMCPEntryPreservesSymlink(t *testing.T) { + dir := t.TempDir() + target := filepath.Join(dir, "managed.toml") + link := filepath.Join(dir, "config.toml") + if err := os.WriteFile(target, []byte("model = 'gpt-6-astra'\n"), 0600); err != nil { + t.Fatal(err) + } + if err := os.Symlink(target, link); err != nil { + t.Skip("symlinks unavailable") + } + if _, err := WriteCodexMCPEntry(link, nil); err != nil { + t.Fatal(err) + } + info, err := os.Lstat(link) + if err != nil || info.Mode()&os.ModeSymlink == 0 { + t.Fatal("symlink was replaced") + } + got, err := os.ReadFile(target) + if err != nil || !CodexMCPEntryExists(string(got)) { + t.Fatal("target was not updated") + } +} + +func TestCodexMCPUpdateIsIdempotent(t *testing.T) { + first, err := upsertCodexMCPEntry("model = 'gpt-6-astra'\n", "qmax-code", nil) + if err != nil { + t.Fatal(err) + } + second, err := upsertCodexMCPEntry(first, "qmax-code", nil) + if err != nil || first != second { + t.Fatal("repeated turns change configuration") + } +} diff --git a/internal/agent/setup_orch_test.go b/internal/agent/setup_orch_test.go index eb87e22..9bf1cda 100644 --- a/internal/agent/setup_orch_test.go +++ b/internal/agent/setup_orch_test.go @@ -12,8 +12,11 @@ func TestUpsertCodexMCPEntryAddsQMaxTable(t *testing.T) { trust_level = "trusted" ` - got := upsertCodexMCPEntry(input, "qmax-code", nil) + got, err := upsertCodexMCPEntry(input, "qmax-code", nil) + if err != nil { + t.Fatal(err) + } for _, want := range []string{ `model = "gpt-5.5"`, `[projects."/tmp/app"]`, @@ -43,8 +46,11 @@ env = { "QMAX_PROJECT_ID" = "7" } enabled = true ` - got := upsertCodexMCPEntry(input, "qmax-code", map[string]string{"QMAX_PROJECT_ID": "42"}) + got, err := upsertCodexMCPEntry(input, "qmax-code", map[string]string{"QMAX_PROJECT_ID": "42"}) + if err != nil { + t.Fatal(err) + } if strings.Contains(got, "/old/qmax-code") || strings.Contains(got, `args = ["serve"]`) { t.Fatalf("stale qmax entry was not replaced:\n%s", got) } @@ -66,10 +72,10 @@ enabled = true } func TestCodexMCPEntryExists(t *testing.T) { - if !codexMCPEntryExists("\n[mcp_servers.qmax]\ncommand = \"qmax-code\"\n") { + if !CodexMCPEntryExists("\n[mcp_servers.qmax]\ncommand = \"qmax-code\"\n") { t.Fatal("expected qmax MCP entry to be detected") } - if codexMCPEntryExists("\n[mcp_servers.qualitymax]\nenabled = true\n") { + if CodexMCPEntryExists("\n[mcp_servers.qualitymax]\nenabled = true\n") { t.Fatal("qualitymax remote entry should not satisfy qmax local entry") } } diff --git a/internal/setup/orch.go b/internal/setup/orch.go index b3519ae..f4cf395 100644 --- a/internal/setup/orch.go +++ b/internal/setup/orch.go @@ -5,7 +5,6 @@ import ( "fmt" "os" "path/filepath" - "strings" "github.com/Quality-Max/qmax-code/internal/agent" "github.com/Quality-Max/qmax-code/internal/skills" @@ -283,14 +282,7 @@ func IsOrchInstalled(backend string) bool { } if backend == "codex" { - // Inline check — avoid exporting codexMCPEntryExists since this is - // the only caller outside the agent package. - for _, line := range strings.Split(string(data), "\n") { - if strings.TrimSpace(line) == "[mcp_servers.qmax]" { - return true - } - } - return false + return agent.CodexMCPEntryExists(string(data)) } var cfg map[string]interface{} diff --git a/internal/setup/orch_test.go b/internal/setup/orch_test.go index 3fde404..3a568cd 100644 --- a/internal/setup/orch_test.go +++ b/internal/setup/orch_test.go @@ -17,6 +17,30 @@ func withTempHome(t *testing.T) string { return tmp } +func TestIsOrchInstalledCodexParsesTables(t *testing.T) { + home := t.TempDir() + t.Setenv("HOME", home) + dir := filepath.Join(home, ".codex") + if err := os.MkdirAll(dir, 0700); err != nil { + t.Fatal(err) + } + for _, tc := range []struct { + config string + want bool + }{ + {`[mcp_servers."qmax"] # user comment`, true}, + {"notes = '''\n[mcp_servers.qmax]\n'''", false}, + {"[mcp_servers.qmax]\ninvalid = [", false}, + } { + if err := os.WriteFile(filepath.Join(dir, "config.toml"), []byte(tc.config), 0600); err != nil { + t.Fatal(err) + } + if got := IsOrchInstalled("codex"); got != tc.want { + t.Fatalf("installed = %v, want %v", got, tc.want) + } + } +} + func TestInstallCodexWritesConfigTOML(t *testing.T) { home := withTempHome(t)