agent-toggle 0.17.0__tar.gz → 0.19.0__tar.gz

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-toggle
-Version: 0.17.0
+Version: 0.19.0
 Summary: Temporarily disable / re-enable AI-agent skills, agents, commands, rules, plugins and MCP servers across harnesses (Claude Code, Codex, Grok, OpenCode, OpenClaw, Copilot, Vibe, Devin, Antigravity)
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/weskao/agent-toggle
@@ -665,7 +665,9 @@ visible rather than silent.
 
 ## MCP backups are verbatim
 
-- **Claude**: the raw entry from `~/.claude.json`. Never `claude mcp get` —
+- **Claude**: only servers an older agent-toggle removed have one; a disable now marks the
+  server off in place (see [Claude MCP scopes](#claude-mcp-scopes)). The backup is the raw
+  entry from `~/.claude.json`. Never `claude mcp get` —
   that prints a human summary and silently drops auth fields (`headers`,
   `headersHelper`), so a server restored from it fails with 401.
 - **Codex**: the exact `[mcp_servers.<name>]` text block including its
@@ -687,15 +689,20 @@ Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
 
 | scope | lives in | toggle |
 |---|---|---|
-| user | top-level `mcpServers` | ✓ |
-| local | `projects/<dir>/mcpServers` | ✓ — project path saved with the backup |
+| user | top-level `mcpServers` | ✓ — the entry stays; recorded in each *existing* project's `disabledMcpServers` |
+| local | `projects/<dir>/mcpServers` | ✓ — as user scope |
 | project | the repo's own `.mcp.json` | ✓ with `--project <dir>` only, see [Project scope](#project-scope) |
 | claude.ai connector | your account | ✓ — recorded in each *existing* project's `disabledMcpServers`; a project first opened later needs the toggle re-run |
 
-`claude mcp remove -s local` only sees the project it runs in, so the project
-path is recorded at disable time and the restore runs back in that directory.
-One name that is local-scope in several projects is refused unless your cwd
-picks the winner — guessing would restore it into the wrong project.
+Claude Code reads its MCP config once, at session start, and `/mcp enable` reaches only a server
+it listed then. A removed server could not load until a new session, so a user- or local-scope
+server is never removed: it stays in `~/.claude.json`, off in every project that existed at
+disable time. A project first opened later loads it, and the mod turns it off at that session's
+start (`/mcp disable`, which also marks the project). Without the mod, re-run the disable.
+
+A server an older agent-toggle removed still comes back from its backup, with
+`claude mcp add-json` run in the project recorded at disable time. A running session did not list
+it, so it loads in a new session.
 
 ## Profiles
 
@@ -1022,8 +1029,9 @@ The mod and the CLI share one version. To run your own checkout instead (edits r
 claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
 ```
 
-- `/agent-toggle` or `/agent-toggle open` opens the pane, `/agent-toggle close` closes it,
-  `/agent-toggle toggle` does whichever applies; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
+- `/agent-toggle` (or `/agent-toggle toggle`) closes the pane when it is shown and opens it otherwise
+  (a pane behind another tab comes to the front); `/agent-toggle open` always opens, `/agent-toggle close`
+  always closes; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
   also closes it. Claude can do the same when you ask it to open or close agent-toggle: the mod
   registers a `pane` tool (`mcp__agent-toggle__pane`, `action`: `open` | `close` | `toggle`),
   e.g. "open agent-toggle", "close the agent-toggle pane", "toggle the agent-toggle pane".
@@ -1063,6 +1071,12 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
   leaves the per-project mark that `enable` clears (see
   [MCP backups are verbatim](#mcp-backups-are-verbatim)).
+  `/mcp` only reaches a server the session listed at its start. The CLI keeps a disabled server
+  listed, so `/mcp enable` loads it in any session, even one started while it was off. Only a
+  server an older version removed and `enable` restores from its backup gets no command; its note
+  says `example-mcp: loads in a new session`. At session start the mod also runs
+  `/mcp disable <name>` for each server agent-toggle keeps off that the session's project has not
+  marked (a project dir first opened after the disable).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/README.md

@@ -631,7 +631,9 @@ visible rather than silent.
 
 ## MCP backups are verbatim
 
-- **Claude**: the raw entry from `~/.claude.json`. Never `claude mcp get` —
+- **Claude**: only servers an older agent-toggle removed have one; a disable now marks the
+  server off in place (see [Claude MCP scopes](#claude-mcp-scopes)). The backup is the raw
+  entry from `~/.claude.json`. Never `claude mcp get` —
   that prints a human summary and silently drops auth fields (`headers`,
   `headersHelper`), so a server restored from it fails with 401.
 - **Codex**: the exact `[mcp_servers.<name>]` text block including its
@@ -653,15 +655,20 @@ Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
 
 | scope | lives in | toggle |
 |---|---|---|
-| user | top-level `mcpServers` | ✓ |
-| local | `projects/<dir>/mcpServers` | ✓ — project path saved with the backup |
+| user | top-level `mcpServers` | ✓ — the entry stays; recorded in each *existing* project's `disabledMcpServers` |
+| local | `projects/<dir>/mcpServers` | ✓ — as user scope |
 | project | the repo's own `.mcp.json` | ✓ with `--project <dir>` only, see [Project scope](#project-scope) |
 | claude.ai connector | your account | ✓ — recorded in each *existing* project's `disabledMcpServers`; a project first opened later needs the toggle re-run |
 
-`claude mcp remove -s local` only sees the project it runs in, so the project
-path is recorded at disable time and the restore runs back in that directory.
-One name that is local-scope in several projects is refused unless your cwd
-picks the winner — guessing would restore it into the wrong project.
+Claude Code reads its MCP config once, at session start, and `/mcp enable` reaches only a server
+it listed then. A removed server could not load until a new session, so a user- or local-scope
+server is never removed: it stays in `~/.claude.json`, off in every project that existed at
+disable time. A project first opened later loads it, and the mod turns it off at that session's
+start (`/mcp disable`, which also marks the project). Without the mod, re-run the disable.
+
+A server an older agent-toggle removed still comes back from its backup, with
+`claude mcp add-json` run in the project recorded at disable time. A running session did not list
+it, so it loads in a new session.
 
 ## Profiles
 
@@ -988,8 +995,9 @@ The mod and the CLI share one version. To run your own checkout instead (edits r
 claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
 ```
 
-- `/agent-toggle` or `/agent-toggle open` opens the pane, `/agent-toggle close` closes it,
-  `/agent-toggle toggle` does whichever applies; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
+- `/agent-toggle` (or `/agent-toggle toggle`) closes the pane when it is shown and opens it otherwise
+  (a pane behind another tab comes to the front); `/agent-toggle open` always opens, `/agent-toggle close`
+  always closes; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
   also closes it. Claude can do the same when you ask it to open or close agent-toggle: the mod
   registers a `pane` tool (`mcp__agent-toggle__pane`, `action`: `open` | `close` | `toggle`),
   e.g. "open agent-toggle", "close the agent-toggle pane", "toggle the agent-toggle pane".
@@ -1029,6 +1037,12 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
   leaves the per-project mark that `enable` clears (see
   [MCP backups are verbatim](#mcp-backups-are-verbatim)).
+  `/mcp` only reaches a server the session listed at its start. The CLI keeps a disabled server
+  listed, so `/mcp enable` loads it in any session, even one started while it was off. Only a
+  server an older version removed and `enable` restores from its backup gets no command; its note
+  says `example-mcp: loads in a new session`. At session start the mod also runs
+  `/mcp disable <name>` for each server agent-toggle keeps off that the session's project has not
+  marked (a project dir first opened after the disable).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/agent_toggle/__init__.py

@@ -1,3 +1,3 @@
 """agent-toggle: temporarily disable / re-enable AI-agent resources."""
 
-__version__ = "0.17.0"
+__version__ = "0.19.0"

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/agent_toggle/mechanisms.py

@@ -18,7 +18,6 @@ from .backends.mcp_json import (
     _finite,
     _no_dup,
     _not_json,
-    claude_mcp_config,
     claudeai_connector_names,
     project_mcp_backup,
     project_mcp_remove,
@@ -1042,7 +1041,13 @@ def toggle_mcp(action: str, names: list[str], state: dict,
             fails += fail(name, refused)
             continue
 
-        if backend == "claude-json" and name in claudeai_connector_names():
+        connector = backend == "claude-json" and name in claudeai_connector_names()
+        # A configured server is marked off per project like a connector, never removed:
+        # Claude Code builds its MCP list once per session and `/mcp enable` reaches only a
+        # listed server, so a removed one could not load until a new session.
+        if connector or backend == "claude-json" and (
+                (entry or {}).get("connector")
+                or action == "disable" and name in live_mcp(home, backend)):
             ok, detail = toggle_claudeai_connector(action, name, dry_run)
             if not ok:
                 fails += fail(name, str(detail))
@@ -1057,15 +1062,17 @@ def toggle_mcp(action: str, names: list[str], state: dict,
                     }
                 _ok(out, dry_run, harness, "mcp", action, name,
                     f"disabled across {n} project(s) "
-                    f"(claude.ai connector -- account stays connected, "
-                    f"just parked per-project; new project dirs need a re-run)",
+                    + ("(claude.ai connector -- account stays connected, "
+                       "just parked per-project; new project dirs need a re-run)" if connector
+                       else "(config kept in ~/.claude.json; the mod marks new project dirs)"),
                     connector=True, projects=detail)
             else:
                 if not dry_run:
                     state["disabled"].pop(key, None)
                 _ok(out, dry_run, harness, "mcp", action, name,
                     f"restored across {n} project(s) "
-                    f"(open a NEW session for it to load)",
+                    + ("(open a NEW session for it to load)" if connector
+                       else f"(`/mcp enable {name}` loads it in a running session)"),
                     connector=True, projects=detail)
             if not dry_run:
                 log(action, "mcp", name, "ok", json.dumps(detail), harness=harness,
@@ -1076,35 +1083,23 @@ def toggle_mcp(action: str, names: list[str], state: dict,
         scope, project = "user", None
 
         if action == "disable":
-            if backend == "claude-json":
-                try:
-                    found = claude_mcp_config(name)
-                except LookupError as e:
-                    fails += fail(name, str(e))
-                    continue
-                if found is None:
-                    hint = ("not in ~/.claude.json (user or local scope) -- "
-                            "a repo's own .mcp.json needs --project <dir>")
-                    if not dry_run:      # a dry run never shells out to claude
-                        ok, cfg = run_cli(claude_bin(), ["mcp", "get", name])
-                        if ok and "claude.ai config" in cfg:
-                            hint = ("account-level claude.ai connector -- disable it "
-                                    "at claude.ai (Settings -> Connectors)")
-                    fails += fail(name, hint)
-                    continue
-                raw, scope, project = found
-                if dry_run and not claude_bin():
-                    fails += fail(name, "claude CLI not found")
-                    continue
-                saved = json.dumps(raw, indent=2, ensure_ascii=False)
-            else:  # toml
-                config = home / "config.toml"
-                # plan first, back up, THEN edit: the block is never only in memory
-                block = codex_mcp_remove(config, name, True) if config.exists() else None
-                if block is None:
-                    fails += fail(name, f"no [mcp_servers.{name}] in {config}")
-                    continue
-                saved = json.dumps({"toml": block}, ensure_ascii=False, indent=2)
+            if backend == "claude-json":         # a configured server was marked off above
+                hint = ("not in ~/.claude.json (user or local scope) -- "
+                        "a repo's own .mcp.json needs --project <dir>")
+                if not dry_run:      # a dry run never shells out to claude
+                    ok, cfg = run_cli(claude_bin(), ["mcp", "get", name])
+                    if ok and "claude.ai config" in cfg:
+                        hint = ("account-level claude.ai connector -- disable it "
+                                "at claude.ai (Settings -> Connectors)")
+                fails += fail(name, hint)
+                continue
+            config = home / "config.toml"
+            # plan first, back up, THEN edit: the block is never only in memory
+            block = codex_mcp_remove(config, name, True) if config.exists() else None
+            if block is None:
+                fails += fail(name, f"no [mcp_servers.{name}] in {config}")
+                continue
+            saved = json.dumps({"toml": block}, ensure_ascii=False, indent=2)
 
             where = f" [{scope}{f': {project}' if project else ''}]"
             if not dry_run:
@@ -1123,25 +1118,14 @@ def toggle_mcp(action: str, names: list[str], state: dict,
                             bp.unlink(missing_ok=True)
                     fails += fail(name, f"state not saved, nothing changed: {e}")
                     continue
-                if backend == "claude-json":
-                    ok, res = run_cli(claude_bin(), ["mcp", "remove", name, "-s", scope],
-                                      cwd=project)
-                    err = None if ok else redact(res, raw)[:100]
-                else:
-                    try:
-                        codex_mcp_remove(config, name)
-                        err = None
-                    except fs.WriteError as e:      # config rolled back
-                        err = str(e)
-                if err is not None:     # settled from the file: untouched -> backup dropped
-                    settle(state, key, out, inline=True)
-                    fails += fail(name, err)
+                try:
+                    codex_mcp_remove(config, name)
+                except fs.WriteError as e:      # config rolled back; settled from the file:
+                    settle(state, key, out, inline=True)    # untouched -> backup dropped
+                    fails += fail(name, str(e))
                     continue
                 state["disabled"][key] = new
                 end(state, key)
-                # claude local scope logs its real scope + cwd; undo treats every
-                # scope but `project` (a --project change) as user scope, which is right
-                # for local: the replay finds the user-keyed entry and its own cwd.
                 log(action, "mcp", name, "ok", str(bp), harness=harness, batch=batch,
                     project=project, scope=scope)
             _ok(out, dry_run, harness, "mcp", action, name,

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/agent_toggle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-toggle
-Version: 0.17.0
+Version: 0.19.0
 Summary: Temporarily disable / re-enable AI-agent skills, agents, commands, rules, plugins and MCP servers across harnesses (Claude Code, Codex, Grok, OpenCode, OpenClaw, Copilot, Vibe, Devin, Antigravity)
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/weskao/agent-toggle
@@ -665,7 +665,9 @@ visible rather than silent.
 
 ## MCP backups are verbatim
 
-- **Claude**: the raw entry from `~/.claude.json`. Never `claude mcp get` —
+- **Claude**: only servers an older agent-toggle removed have one; a disable now marks the
+  server off in place (see [Claude MCP scopes](#claude-mcp-scopes)). The backup is the raw
+  entry from `~/.claude.json`. Never `claude mcp get` —
   that prints a human summary and silently drops auth fields (`headers`,
   `headersHelper`), so a server restored from it fails with 401.
 - **Codex**: the exact `[mcp_servers.<name>]` text block including its
@@ -687,15 +689,20 @@ Both scopes stored in `~/.claude.json` are togglable, and the scope round-trips:
 
 | scope | lives in | toggle |
 |---|---|---|
-| user | top-level `mcpServers` | ✓ |
-| local | `projects/<dir>/mcpServers` | ✓ — project path saved with the backup |
+| user | top-level `mcpServers` | ✓ — the entry stays; recorded in each *existing* project's `disabledMcpServers` |
+| local | `projects/<dir>/mcpServers` | ✓ — as user scope |
 | project | the repo's own `.mcp.json` | ✓ with `--project <dir>` only, see [Project scope](#project-scope) |
 | claude.ai connector | your account | ✓ — recorded in each *existing* project's `disabledMcpServers`; a project first opened later needs the toggle re-run |
 
-`claude mcp remove -s local` only sees the project it runs in, so the project
-path is recorded at disable time and the restore runs back in that directory.
-One name that is local-scope in several projects is refused unless your cwd
-picks the winner — guessing would restore it into the wrong project.
+Claude Code reads its MCP config once, at session start, and `/mcp enable` reaches only a server
+it listed then. A removed server could not load until a new session, so a user- or local-scope
+server is never removed: it stays in `~/.claude.json`, off in every project that existed at
+disable time. A project first opened later loads it, and the mod turns it off at that session's
+start (`/mcp disable`, which also marks the project). Without the mod, re-run the disable.
+
+A server an older agent-toggle removed still comes back from its backup, with
+`claude mcp add-json` run in the project recorded at disable time. A running session did not list
+it, so it loads in a new session.
 
 ## Profiles
 
@@ -1022,8 +1029,9 @@ The mod and the CLI share one version. To run your own checkout instead (edits r
 claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
 ```
 
-- `/agent-toggle` or `/agent-toggle open` opens the pane, `/agent-toggle close` closes it,
-  `/agent-toggle toggle` does whichever applies; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
+- `/agent-toggle` (or `/agent-toggle toggle`) closes the pane when it is shown and opens it otherwise
+  (a pane behind another tab comes to the front); `/agent-toggle open` always opens, `/agent-toggle close`
+  always closes; any other argument that is not a CLI command (below) prints the usage. Ctrl-X X
   also closes it. Claude can do the same when you ask it to open or close agent-toggle: the mod
   registers a `pane` tool (`mcp__agent-toggle__pane`, `action`: `open` | `close` | `toggle`),
   e.g. "open agent-toggle", "close the agent-toggle pane", "toggle the agent-toggle pane".
@@ -1063,6 +1071,12 @@ claude --plugin-dir ./mod    # then run /agent-toggle inside Claude
   `/reload-skills` and `/reload-plugins` only re-read what is on disk. `/mcp disable` also
   leaves the per-project mark that `enable` clears (see
   [MCP backups are verbatim](#mcp-backups-are-verbatim)).
+  `/mcp` only reaches a server the session listed at its start. The CLI keeps a disabled server
+  listed, so `/mcp enable` loads it in any session, even one started while it was off. Only a
+  server an older version removed and `enable` restores from its backup gets no command; its note
+  says `example-mcp: loads in a new session`. At session start the mod also runs
+  `/mcp disable <name>` for each server agent-toggle keeps off that the session's project has not
+  marked (a project dir first opened after the disable).
 - `agent-toggle ui` in another terminal applies on Enter and writes the Claude rows it changed to
   `~/.agent-toggle/reload.json`. Every open session running the mod checks that file's mtime every
   5 s (one `stat`) and queues the same reloads, toasting `agent-toggle ui: /reload-skills`. A file

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_all_type.py

@@ -5,7 +5,7 @@ import json
 
 from test_cli_surface import CliCase
 
-from agent_toggle import fs, mechanisms
+from agent_toggle import fs
 
 
 class AllTypeTest(CliCase):
@@ -42,9 +42,6 @@ class AllTypeTest(CliCase):
 
     def test_mcp_with_the_same_name_is_included(self) -> None:
         self.claude_json({"mcpServers": {"dup": {"command": "dup-server"}}})
-        saved = mechanisms.claude_mcp_config
-        self.addCleanup(setattr, mechanisms, "claude_mcp_config", saved)
-        mechanisms.claude_mcp_config = lambda name: ({"command": "dup-server"}, "user", None)
         rc, env = self.run_json("disable", "all", "dup")
         self.assertEqual(rc, 0)
         self.assertIn(("mcp", "ok"), [(r["type"], r["status"]) for r in env["results"]])

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_backends.py

@@ -103,13 +103,15 @@ class ClaudeJsonScopeTest(SandboxCase):
         # ambiguous local scope is refused
         with self.assertRaisesRegex(LookupError, "2 projects"):
             mcp_json.claude_mcp_config("dup")
+        # a disable marks it off in every project and never removes either copy, so
+        # nothing has to be guessed
         state = {"version": 2, "disabled": {}}
         fails = mechanisms.toggle_mcp("disable", ["dup"], state, "claude", self.home,
                                       "claude-json")
-        # ambiguity counts as a failure, not a crash
-        self.assertEqual(fails, 1)
-        # nothing recorded for the ambiguous server
-        self.assertFalse(state["disabled"])
+        self.assertEqual(fails, 0)
+        projects = json.loads(fs.claude_json().read_text(encoding="utf-8"))["projects"]
+        self.assertEqual([(d["mcpServers"]["dup"]["command"], d["disabledMcpServers"])
+                          for d in projects.values()], [("a", ["dup"]), ("b", ["dup"])])
 
     def test_mcp_enable_defaults_to_user_scope_for_old_entries(self) -> None:
         """Entries parked before scope tracking have no scope field."""
@@ -151,6 +153,39 @@ class ClaudeJsonScopeTest(SandboxCase):
         self.assertEqual(projects["/work/a"]["disabledMcpServers"], ["other"])
         self.assertEqual(projects["/work/b"]["disabledMcpServers"], ["other"])
 
+    def test_configured_server_is_marked_off_in_place(self) -> None:
+        """Claude Code builds its MCP list once per session and `/mcp enable` reaches only a
+        listed server: disable keeps the config entry and marks it off per project, so a
+        session started while it is off still lists it and `/mcp enable` loads it there."""
+        entry = {"type": "http", "url": "https://example.invalid/mcp"}
+        self.claude_json({"mcpServers": {"example-mcp": entry}, "projects": {
+            "/work/a": {"disabledMcpServers": ["other"]}, "/work/b": {}}})
+        state = {"version": 3, "disabled": {}}
+        out = Result()
+        fails = mechanisms.toggle_mcp("disable", ["example-mcp"], state, "claude",
+                                      self.home, "claude-json", out)
+        self.assertEqual(fails, 0)
+        cfg = json.loads(fs.claude_json().read_text(encoding="utf-8"))
+        # the entry stays where it was; no `claude mcp remove`, no backup file
+        self.assertEqual(cfg["mcpServers"]["example-mcp"], entry)
+        self.assertEqual(self.cli_calls, [])
+        self.assertFalse(mechanisms._json_backup_path("claude", "example-mcp").exists())
+        self.assertEqual({p: d.get("disabledMcpServers") for p, d in cfg["projects"].items()},
+                         {"/work/a": ["other", "example-mcp"], "/work/b": ["example-mcp"]})
+        row = out.rows[-1]
+        self.assertEqual((row["status"], row.get("connector"), row.get("backup")), ("ok", True, None))
+        self.assertTrue(state["disabled"]["claude:mcp:example-mcp"]["connector"])
+
+        fails = mechanisms.toggle_mcp("enable", ["example-mcp"], state, "claude",
+                                      self.home, "claude-json", Result())
+        self.assertEqual(fails, 0)
+        cfg = json.loads(fs.claude_json().read_text(encoding="utf-8"))
+        self.assertEqual(cfg["mcpServers"]["example-mcp"], entry)
+        self.assertEqual({p: d.get("disabledMcpServers") for p, d in cfg["projects"].items()},
+                         {"/work/a": ["other"], "/work/b": []})
+        self.assertEqual(state["disabled"], {})
+        self.assertEqual(self.cli_calls, [])
+
 
 FIXTURES = Path(__file__).parent / "fixtures"
 

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_conformance.py

@@ -98,11 +98,11 @@ class ConformanceTest(CliCase):
         self.assertEqual(self.run_cli("disable", "mcp", "example-mcp")[0], 0)
         self.assertEqual(self.run_cli("enable", "mcp", "example-mcp")[0], 0)
         calls = [c for c, _ in self.cli_calls]
-        self.assertEqual(calls[:3], [["plugin", "disable", "demo-plugin"],
-                                     ["plugin", "enable", "demo-plugin"],
-                                     ["mcp", "remove", "example-mcp", "-s", "user"]])
-        self.assertEqual(calls[3][:4], ["mcp", "add-json", "--scope", "user"])
-        self.assertEqual(json.loads(calls[3][5]), orig)     # restored payload is the original
+        # an MCP server is marked off in place: no `claude mcp remove|add-json`
+        self.assertEqual(calls, [["plugin", "disable", "demo-plugin"],
+                                 ["plugin", "enable", "demo-plugin"]])
+        cfg = json.loads((self.tmp / ".claude.json").read_text(encoding="utf-8"))
+        self.assertEqual(cfg["mcpServers"]["example-mcp"], orig)
 
     def test_dry_run_writes_nothing(self) -> None:
         for harness, type_ in PAIRS:

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_crash.py

@@ -850,8 +850,10 @@ class PluginCrashTest(CliCrashCase):
 
 
 class ClaudeMcpCrashTest(CliCrashCase):
-    """claude MCP servers: `claude mcp remove|add-json` write ~/.claude.json, so settle
-    reads that file strictly (no CLI call); unreadable -> stuck."""
+    """claude MCP servers an older version removed (`claude mcp remove`, config in a
+    backup): enable's `claude mcp add-json` writes ~/.claude.json, so settle reads that
+    file strictly (no CLI call); unreadable -> stuck. A disable now only marks a server
+    off (no write-ahead), so a pending disable is one an older version left."""
 
     KEY = "claude:mcp:demo-mcp"
     ARGS = ("mcp", "demo-mcp", "--harness", "claude")
@@ -873,8 +875,35 @@ class ClaudeMcpCrashTest(CliCrashCase):
                 "name": "demo-mcp", "backend": "claude-json", "backup": str(self.bp),
                 "scope": "user", "project": None, "at": "2026-01-01T00:00:00+0000", **fields}
 
+    def old_disable(self, landed: bool, name: str = "demo-mcp", project: str | None = None) -> None:
+        """A disable by an older version, killed around its `claude mcp remove`: the
+        backup written, the op pending, the server gone from ~/.claude.json if it landed."""
+        cfg = json.loads(self.cj.read_text(encoding="utf-8"))
+        box = cfg if project is None else cfg["projects"][project]
+        bp = fs.backup_dir() / f"claude__{name}.json"
+        fs.private_dir(fs.backup_dir())
+        bp.write_text(json.dumps(box["mcpServers"][name]), encoding="utf-8")
+        if landed:
+            del box["mcpServers"][name]
+            self.cj.write_text(json.dumps(cfg), encoding="utf-8")
+        self.forge(f"claude:mcp:{name}", "disable", self.entry(
+            name=name, backup=str(bp), scope="local" if project else "user", project=project))
+
+    def old_disabled(self) -> None:
+        """A server an older version disabled: removed, its config in the backup."""
+        self.old_disable(landed=True)
+        store.save_state({"version": 3, "disabled": {self.KEY: self.entry()}})
+
+    def test_a_disable_marks_it_off_and_never_calls_the_cli(self) -> None:
+        self.assertEqual(self.run_json("disable", *self.ARGS)[0], 0)
+        self.assertNotIn("pending", self.raw_state())
+        self.assertIn(self.KEY, self.raw_state()["disabled"])
+        self.assertIn("demo-mcp", self.servers())
+        self.assertFalse(self.bp.exists())
+        self.assertEqual(self.cli_calls, [])
+
     def test_kill_after_the_cli_remove_is_recorded_and_restorable(self) -> None:
-        self.kill_in_cli("disable", *self.ARGS, landed=True)
+        self.old_disable(landed=True)
         self.assertEqual(self.pending()[self.KEY]["entry"]["backend"], "claude-json")
         self.assertNotIn("demo-mcp", self.servers())
         self.assertEqual(self.raw_state()["disabled"], {})
@@ -890,7 +919,7 @@ class ClaudeMcpCrashTest(CliCrashCase):
         self.assertEqual(self.servers()["demo-mcp"], {"command": "demo"})
 
     def test_kill_before_the_cli_remove_rolls_back_and_drops_the_backup(self) -> None:
-        self.kill_in_cli("disable", *self.ARGS, landed=False)
+        self.old_disable(landed=False)
         self.assertTrue(self.bp.exists())
         self.assertTrue(any("never reached disk" in w for w in self.warnings("status")))
         self.run_json(*NEXT)
@@ -898,15 +927,14 @@ class ClaudeMcpCrashTest(CliCrashCase):
         self.assertFalse(self.bp.exists())
 
     def test_kill_after_the_cli_add_drops_the_entry(self) -> None:
-        self.assertEqual(self.run_json("disable", *self.ARGS)[0], 0)
-        self.assertNotIn("pending", self.raw_state())
+        self.old_disabled()
         self.kill_in_cli("enable", *self.ARGS, landed=True)
         self.assertEqual(len(self.doctor_rows("done")), 1)
         self.run_json(*NEXT)
         self.assert_settled(False)
 
     def test_kill_before_the_cli_add_keeps_it_disabled(self) -> None:
-        self.assertEqual(self.run_json("disable", *self.ARGS)[0], 0)
+        self.old_disabled()
         self.kill_in_cli("enable", *self.ARGS, landed=False)
         self.assertEqual(len(self.doctor_rows("undone")), 1)
         self.run_json(*NEXT)
@@ -915,20 +943,21 @@ class ClaudeMcpCrashTest(CliCrashCase):
 
     def test_settle_needs_no_cli(self) -> None:
         from agent_toggle.backends import plugin_cli
-        self.kill_in_cli("disable", *self.ARGS, landed=True)
+        self.old_disable(landed=True)
         plugin_cli.which = lambda name: None
         self.run_json(*NEXT)
         self.assert_settled(True)
 
-    def test_a_failed_cli_remove_settles_inline(self) -> None:
+    def test_a_failed_cli_add_settles_inline(self) -> None:
+        self.old_disabled()
         self.broken = True
-        rc, env = self.run_json("disable", *self.ARGS)
+        rc, env = self.run_json("enable", *self.ARGS)
         self.assertEqual(rc, 1)
-        self.assert_settled(False)
-        self.assertFalse(self.bp.exists())
+        self.assert_settled(True)
+        self.assertTrue(self.bp.exists())
 
     def test_an_unreadable_claude_json_is_stuck_never_guessed(self) -> None:
-        self.kill_in_cli("disable", *self.ARGS, landed=True)
+        self.old_disable(landed=True)
         for body in ("{broken", "[]", '{"mcpServers": []}'):
             with self.subTest(body):
                 self.cj.write_text(body, encoding="utf-8")
@@ -941,7 +970,7 @@ class ClaudeMcpCrashTest(CliCrashCase):
                 self.assertTrue(self.bp.exists())
 
     def test_a_gone_server_without_its_backup_is_stuck(self) -> None:
-        self.kill_in_cli("disable", *self.ARGS, landed=True)
+        self.old_disable(landed=True)
         self.bp.unlink()
         stuck = self.doctor_rows("stuck")
         self.assertEqual(len(stuck), 1, stuck)
@@ -955,7 +984,7 @@ class ClaudeMcpCrashTest(CliCrashCase):
         proj.mkdir()
         self.cj.write_text(json.dumps({"mcpServers": {}, "projects": {
             str(proj): {"mcpServers": {"loc-mcp": {"command": "loc"}}}}}), encoding="utf-8")
-        self.kill_in_cli("disable", "mcp", "loc-mcp", "--harness", "claude", landed=True)
+        self.old_disable(landed=True, name="loc-mcp", project=str(proj))
         entry = self.pending()["claude:mcp:loc-mcp"]["entry"]
         self.assertEqual((entry["scope"], entry["project"]), ("local", str(proj)))
         self.run_json(*NEXT)

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_safety.py

@@ -23,6 +23,14 @@ def mode(p: Path) -> int:
     return p.stat().st_mode & 0o777
 
 
+def codex_toml(home: Path) -> None:
+    """A codex config whose MCP server carries a token: its disable writes a backup."""
+    (home / ".codex").mkdir()
+    (home / ".codex" / "config.toml").write_text(
+        '[mcp_servers.example-mcp]\ncommand = "example"\n\n'
+        '[mcp_servers.example-mcp.env]\nTOKEN = "Bearer test-token-000"\n', encoding="utf-8")
+
+
 class LockTest(SandboxCase):
     def setUp(self) -> None:
         super().setUp()
@@ -121,16 +129,12 @@ class PrivateModeTest(SandboxCase):
         self.assertEqual([x.name for x in self.tmp.glob(".out.json*")], [])
 
     def test_mcp_disable_writes_0600_backup_and_state(self) -> None:
-        raw = {"type": "http", "headers": {"Authorization": "Bearer test-token-000"}}
-        saved = mechanisms.claude_mcp_config
-        self.addCleanup(setattr, mechanisms, "claude_mcp_config", saved)
-        mechanisms.claude_mcp_config = lambda name: (raw, "user", None)
-        self.cli_rc = 0                      # stubbed `claude mcp remove` succeeds
+        codex_toml(self.tmp)
         state = {"version": 3, "disabled": {}}
-        fails = mechanisms.toggle_mcp("disable", ["example-mcp"], state, "claude",
-                                      self.home, "claude-json")
+        fails = mechanisms.toggle_mcp("disable", ["example-mcp"], state, "codex",
+                                      self.tmp / ".codex", "toml")
         self.assertEqual(fails, 0)
-        entry = state["disabled"]["claude:mcp:example-mcp"]
+        entry = state["disabled"]["codex:mcp:example-mcp"]
         self.assertEqual(entry["mechanism"], "remove_backup")
         self.assertEqual(mode(Path(entry["backup"])), 0o600)
         store.save_state(state)
@@ -159,12 +163,8 @@ class PrivateModeTest(SandboxCase):
 class PrivateDirTest(SandboxCase):
     def test_state_backup_dirs_and_log_are_private_under_open_umask(self) -> None:
         self.addCleanup(os.umask, os.umask(0))
-        raw = {"type": "http", "headers": {"Authorization": "Bearer test-token-000"}}
-        saved = mechanisms.claude_mcp_config
-        self.addCleanup(setattr, mechanisms, "claude_mcp_config", saved)
-        mechanisms.claude_mcp_config = lambda name: (raw, "user", None)
-        self.cli_rc = 0
-        self.assertEqual(cli.main(["disable", "mcp", "example-mcp"]), 0)
+        codex_toml(self.tmp)
+        self.assertEqual(cli.main(["disable", "mcp", "example-mcp", "--harness", "codex"]), 0)
         for d in (fs.state_dir(), fs.backup_dir()):
             self.assertEqual(mode(d), 0o700, d)
         self.assertEqual(mode(fs.log_file()), 0o600)

{agent_toggle-0.17.0 → agent_toggle-0.19.0}/tests/test_secret_audit.py

@@ -114,6 +114,23 @@ class SecretAuditTest(CliCase):
                 self.assertEqual(stat.S_IMODE(b.stat().st_mode), 0o600, b)
             self.assertEqual(stat.S_IMODE(fs.backup_dir().stat().st_mode) & 0o077, 0)
 
+    def park_claude_legacy(self) -> None:
+        """The claude servers as an older version disabled them: removed from ~/.claude.json,
+        their config in a backup, so enable runs `claude mcp add-json` with it."""
+        cj = json.loads(fs.claude_json().read_text(encoding="utf-8"))
+        state = store.load_state()
+        fs.private_dir(fs.backup_dir())
+        for name, box, proj in (("secret-mcp", cj, None),
+                                ("local-mcp", cj["projects"][str(self.proj)], str(self.proj))):
+            bp = fs.backup_dir() / f"claude__{name}.json"
+            fs.atomic_write(bp, json.dumps(box["mcpServers"].pop(name), indent=2))
+            state["disabled"][f"claude:mcp:{name}"] = {
+                "mechanism": "remove_backup", "harness": "claude", "type": "mcp", "name": name,
+                "backend": "claude-json", "backup": str(bp), "scope": "local" if proj else "user",
+                "project": proj, "at": "2026-01-01T00:00:00+0000"}
+        fs.claude_json().write_text(json.dumps(cj), encoding="utf-8")
+        store.save_state(state)
+
     def batch(self, name: str):
         return mock.patch.object(store, "BATCH", name)
 
@@ -189,6 +206,7 @@ class SecretAuditTest(CliCase):
 
     def test_cli_error_echoing_the_config_is_redacted(self) -> None:
         self.each("disable")
+        self.park_claude_legacy()
         self.cli_rc = 1                              # add-json fails and echoes its config
         for extra in VARIANTS:
             for t in self.TARGETS[:2]:
@@ -205,6 +223,7 @@ class SecretAuditTest(CliCase):
 
     def test_unexpected_exception_traceback_shows_no_value(self) -> None:
         self.each("disable")
+        self.park_claude_legacy()
 
         def boom(cmd, **kw):
             raise RuntimeError("cli crashed")