claude-multiacc 2.0.58 → 2.0.60

package/lib/mcp_registry.py

@@ -33,8 +33,12 @@ Reconcile rules, the same for both providers:
     any more" needs to hold fleet-wide; a name in `retiredUser` (a learned stock
     `claude mcp remove -s user`, or `mcp remove --user-only`) leaves project
     entries alone, exactly as the client itself did;
-  * anything else the account holds is left alone (an account may carry its own
-    extras);
+  * a server an account holds that no section names, live or retired, is ADOPTED
+    into the registry before the reconcile (`adopt`), and so reaches every account:
+    some route around the shims' mirror put it there (2026-10-22: the operator's
+    `alias claude='claude --dangerously-skip-permissions'` hid every typed
+    `claude mcp add` from it, and motionsites sat in 2 of 11 accounts). Kill switch
+    `<PROVIDER>_MULTIACC_MCP_ADOPT=0`;
   * project-scoped entries (`projects` in the registry) exist for claude only:
     Codex 0.156 reads no per-project config at all.
 
@@ -73,6 +77,12 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 REGISTRY_FILE = "mcp-servers.json"
 OVERLAY_FILE = "mcp-servers.local.json"
 STAMP_FILE = ".mcp-applied"
+#: Every name the pool itself ever wrote into the account (from any section): adoption
+#: never takes one of those back, so a server dropped from a section without a tombstone
+#: (README's recovery for a stray synced entry) or one whose overlay owner vanished is a
+#: stale copy, not a new server — app-robot's machine-specific appinspire-mcp must never
+#: reach the synced registry that way.
+MANAGED_FILE = ".mcp-managed.json"
 LOCK_DIR = os.path.join(".locks", "mcp")
 PROVIDERS = ("claude", "codex")
 CONFIG_FILE = {"claude": ".claude.json", "codex": "config.toml"}
@@ -168,13 +178,14 @@ def _log(root, message):
 class _Lock:
     """mkdir lock, the same shape as lib/common.sh mutate_lock (30 s stale)."""
 
-    def __init__(self, root):
+    def __init__(self, root, wait=60):
         self.path = os.path.join(root, LOCK_DIR)
         self.held = False
+        self.wait = wait
 
     def __enter__(self):
         os.makedirs(os.path.dirname(self.path), exist_ok=True)
-        deadline = time.time() + 60
+        deadline = time.time() + self.wait
         while True:
             try:
                 os.mkdir(self.path)
@@ -864,18 +875,215 @@ def snapshot_codex(account_dir):
 
 # ---------------------------------------------------------------- reconcile
 
+def load_managed(account_dir):
+    """{"user": set(names), "projects": {path: set(names)}} — the account's ledger."""
+    doc = _read_json(os.path.join(account_dir, MANAGED_FILE), {})
+    doc = doc if isinstance(doc, dict) else {}
+    user = doc.get("user") if isinstance(doc.get("user"), list) else []
+    projects = doc.get("projects") if isinstance(doc.get("projects"), dict) else {}
+    return {"user": {str(n) for n in user},
+            "projects": {str(p): {str(n) for n in names} for p, names in projects.items()
+                         if isinstance(names, list)}}
+
+
+def record_managed(provider, account_dir, eff):
+    """Add what this reconcile wrote to the ledger (it only ever grows)."""
+    managed = load_managed(account_dir)
+    user = managed["user"] | set(eff.servers)
+    projects = {path: set(names) for path, names in managed["projects"].items()}
+    if provider == "claude":
+        for path, spec in eff.projects.items():
+            names = set(spec.get("mcpServers") or {})
+            if names:
+                projects[path] = projects.get(path, set()) | names
+    if user == managed["user"] and projects == managed["projects"]:
+        return
+    try:
+        _atomic_write(os.path.join(account_dir, MANAGED_FILE), json.dumps(
+            {"user": sorted(user), "projects": {p: sorted(n) for p, n in sorted(projects.items())}},
+            indent=2) + "\n")
+    except OSError:
+        pass
+
+
 def apply_account(root, provider, account_dir):
     eff = effective(load_registry(root), load_overlay(root))
     if provider == "claude":
         state = apply_claude(account_dir, eff)
     else:
         state = apply_codex(account_dir, eff)
+    record_managed(provider, account_dir, eff)
     write_stamp(root, provider, account_dir)
     return state
 
 
+def _adopt_enabled(provider):
+    return os.environ.get(f"{provider.upper()}_MULTIACC_MCP_ADOPT", "1") != "0"
+
+
+def _unknown(eff, snap, managed=None):
+    """What one account's snapshot holds that no section names, live or retired:
+    [(scope, path, name, block)] (path None for user scope). A project's `.mcp.json`
+    approvals are NOT adopted: one account's click would override another's rejection
+    (`disabledMcpjsonServers`) everywhere — only a mirrored `claude mcp` command carries one."""
+    managed = managed or {"user": set(), "projects": {}}
+    found = []
+    for name, block in (snap.get("user") or {}).items():
+        if not isinstance(block, dict):
+            continue
+        if name in eff.servers or name in eff.retired or name in eff.retired_user \
+                or name in managed["user"]:
+            continue
+        found.append(("user", None, name, block))
+    if snap.get("provider") != "claude":
+        return found
+    for path, entry in (snap.get("projects") or {}).items():
+        spec = eff.projects.get(path) or {}
+        known = set(spec.get("mcpServers") or {}) | set(spec.get("retired") or []) \
+            | eff.retired | managed["projects"].get(path, set())
+        for name, block in (entry.get("mcpServers") or {}).items():
+            if isinstance(block, dict) and name not in known:
+                found.append(("project", path, name, block))
+    return found
+
+
+def _still_unknown(eff, scope, path, name):
+    if scope == "user":
+        return not (name in eff.servers or name in eff.retired or name in eff.retired_user)
+    spec = eff.projects.get(path) or {}
+    return not (name in (spec.get("mcpServers") or {}) or name in (spec.get("retired") or [])
+                or name in eff.retired)
+
+
+def _config_mtime(provider, account_dir):
+    try:
+        return os.stat(os.path.join(account_dir, CONFIG_FILE[provider])).st_mtime
+    except OSError:
+        return 0.0
+
+
+def _codex_faithful(name, table):
+    """Whether the registry's codex translation gives this table back as it is (bar the
+    startup timeout default it adds to a stdio server): only then is a codex table adopted,
+    because the reconcile then rewrites the user's own table in that translation."""
+    try:
+        again, _notes = codex_block(name, codex_to_claude(name, table))
+    except RegistryError:
+        return False
+    if again is None:
+        return False
+    again = dict(again)
+    if "startup_timeout_sec" not in table and again.get("startup_timeout_sec") == 60:
+        again.pop("startup_timeout_sec")
+    if not table.get("args") and again.get("args") == []:
+        again.pop("args", None)
+    return again == {k: v for k, v in table.items()}
+
+
+def _carries_values(block):
+    """A block whose env or headers hold literal values — a token, an API key — stays on
+    this machine: the synced registry is a plain file pushed to every peer."""
+    for key in ("env", "headers"):
+        values = block.get(key)
+        if isinstance(values, dict) and any(str(v) and not str(v).startswith("${")
+                                            for v in values.values()):
+            return True
+    return False
+
+
+def adopt(root, provider, account_dirs, dry=False, lock_wait=60):
+    """Take every server these accounts hold that no section names into the registry
+    (on a replica: this machine's overlay, like any learned change). The mirror
+    (`learn`) sees only a `mcp add` the shim recognised; anything else — a global
+    option in front of `mcp` (the operator's aliases), the real binary run directly, a
+    hand edit, another tool's installer — left the server in the one account it ran
+    under, for ever. Several accounts holding different definitions of one name: the
+    one most of them hold wins, then the newest config file. Returns the change list
+    (dry: the names it would adopt, nothing written)."""
+    if not account_dirs or not _adopt_enabled(provider):
+        return []
+    eff = effective(load_registry(root), load_overlay(root))
+    variants = {}  # (scope, path, name) -> {canonical json: [count, newest mtime, block]}
+    # Every account votes, whichever one this run reconciles: a single-account apply (the
+    # shim's, before exec) must choose what `apply --all` would, never its own stale copy.
+    voters = list(dict.fromkeys(list(account_dirs) + manifest_account_dirs(root)))
+    for account_dir in voters:
+        try:
+            snap = snapshot(provider, account_dir)
+        except RegistryError:
+            continue  # apply reports an unreadable config itself
+        mtime = _config_mtime(provider, account_dir)
+        for scope, path, name, block in _unknown(eff, snap, load_managed(account_dir)):
+            slot = variants.setdefault((scope, path, name), {})
+            key = json.dumps(block, sort_keys=True)
+            count = slot.setdefault(key, [0, 0.0, block])
+            count[0] += 1
+            count[1] = max(count[1], mtime)
+    if not variants or dry:
+        return sorted(name for _scope, _path, name in variants)  # dry: what would be adopted
+    changes = []
+    synced_changed = local_changed = False
+    with _Lock(root, wait=lock_wait):
+        target = _Target(root)
+        local_overlay = target.overlay if target.replica else load_overlay(root)
+        eff = effective(load_registry(root), load_overlay(root))  # what holds under the lock
+        for (scope, path, name), slot in sorted(variants.items(), key=lambda kv: (
+                kv[0][0], kv[0][1] or "", kv[0][2])):
+            if not _still_unknown(eff, scope, path, name):
+                continue  # named meanwhile (a concurrent add, another machine's push)
+            count, _mtime, block = max(slot.values(), key=lambda v: (v[0], v[1]))
+            if provider == "codex" and not _codex_faithful(name, block):
+                _warn(f'not adopted: "{name}" — the registry cannot express its codex table '
+                      f"as it is; register it with: codex-accounts mcp add")
+                continue
+            try:
+                learned = block if provider == "claude" else codex_to_claude(name, block)
+                validate_block(name, learned)
+            except RegistryError as exc:
+                _warn(f"not adopted: {exc}")
+                continue
+            where = f" (project {path})" if path else ""
+            if _carries_values(learned) and not target.replica:
+                local = local_overlay.setdefault("owners", {}).setdefault(
+                    "local", _normalize_section({}))
+                _upsert(local, name, learned, scope, path)
+                local_changed = True
+                where += " (this machine only: it carries env/header values)"
+            else:
+                _upsert(target.section, name, learned, scope, path)
+                synced_changed = True
+            if len(slot) > 1:
+                changes.append(f'"{name}"{where} (the definition {count} of '
+                               f'{sum(v[0] for v in slot.values())} accounts hold)')
+            else:
+                changes.append(f'"{name}"{where}')
+        if synced_changed:
+            target.save()
+        if local_changed:
+            save_overlay(root, local_overlay)
+    if changes:
+        _log(root, f"adopt {', '.join(changes)} into {target.where}")
+    return changes
+
+
 def apply_many(root, provider, account_dirs, quiet=False, fail_open=False):
-    """Reconcile each dir; returns the number of accounts that could not be."""
+    """Adopt what these accounts hold that no section names, then reconcile each dir;
+    returns the number of accounts that could not be."""
+    try:
+        # a launch must not wait long on a lock left by a killed holder: the next launch
+        # or the limits pass adopts instead
+        adopted = adopt(root, provider, account_dirs, lock_wait=2 if fail_open else 60)
+    except Exception as exc:  # noqa: BLE001 — adoption must never stop a reconcile
+        adopted = []
+        _warn(f"adopt: {type(exc).__name__}: {exc}")
+    if adopted and not quiet:
+        print(f"adopted {', '.join(adopted)}: every {provider} account gets "
+              f"{'it' if len(adopted) == 1 else 'them'}")
+    if adopted and len(account_dirs) < len(manifest_account_dirs(root)):
+        # One account told the registry something new: the others need it as well (the
+        # shims would bring it to each on its next launch; an idle one would wait).
+        # (a dir being seeded is not in the manifest yet: it stays in the list)
+        account_dirs = list(dict.fromkeys(list(account_dirs) + manifest_account_dirs(root)))
     failures = 0
     for account_dir in account_dirs:
         label = os.path.basename(account_dir.rstrip("/"))
@@ -1194,7 +1402,8 @@ def cmd_apply(args, leftovers):
     if args.all or not args.account_dir:
         rc = _apply_all(args, quiet=args.quiet)
         return 0 if args.fail_open else rc
-    failures = apply_many(args.root, args.provider, args.account_dir, quiet=args.quiet)
+    failures = apply_many(args.root, args.provider, args.account_dir, quiet=args.quiet,
+                          fail_open=args.fail_open)
     return 0 if args.fail_open or not failures else 1
 
 
@@ -1251,8 +1460,12 @@ def cmd_import_local(args):
         # it: an owner that stops shipping a server means it, and every account
         # would otherwise keep the stale copy for ever.
         dropped = [name for name in previous["mcpServers"] if name not in servers]
+        # ...and stays retired until it publishes the name again: an account still holding
+        # a copy must never have it adopted into the synced registry (adopt) once the next
+        # import has forgotten the drop.
+        kept = [name for name in previous["retired"] if name not in servers]
         section = _normalize_section({"mcpServers": servers,
-                                      "retired": sorted(set(retired) | set(dropped))})
+                                      "retired": sorted(set(retired) | set(dropped) | set(kept))})
         if previous == section and owner in overlay["owners"]:
             changed = False
         else:
@@ -1330,7 +1543,16 @@ def main(argv=None):
         from codex_python import require_python311
         require_python311(os.path.abspath(__file__))
     if args.mode == "apply" and not _registry_present(args.root):
-        return 0   # nothing registered: every account is already "reconciled"
+        # Nothing registered: every account is already "reconciled" — unless one holds a
+        # server to adopt (the first this pool ever had, added where the mirror never saw).
+        dirs = args.account_dir if args.account_dir and not args.all \
+            else manifest_account_dirs(args.root)
+        try:
+            if not adopt(args.root, args.provider, dirs, dry=True):
+                return 0
+        except Exception as exc:  # noqa: BLE001 — the old no-op, never a failure
+            _warn(f"adopt: {type(exc).__name__}: {exc}")
+            return 0
     if args.mode == "list":
         return cmd_list(args)
     if args.mode == "add":

package/lib/model_catalog.json

@@ -0,0 +1,404 @@
+{
+ "claude": {
+  "efforts": [
+   "low",
+   "medium",
+   "high",
+   "xhigh",
+   "max"
+  ],
+  "families": {
+   "fable": 5,
+   "haiku": 2,
+   "mythos": 5,
+   "opus": 4,
+   "sonnet": 3
+  },
+  "fetched_at": "2026-10-14T08:49:41Z",
+  "models": {
+   "claude-fable-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "fable",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-fable-5-1": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "fable",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     1
+    ]
+   },
+   "claude-haiku-4-5-20251001": {
+    "default_effort": null,
+    "efforts": [],
+    "family": "haiku",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     5
+    ]
+   },
+   "claude-haiku-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "haiku",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   },
+   "claude-opus-4-6": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     6
+    ]
+   },
+   "claude-opus-4-7": {
+    "default_effort": "xhigh",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     7
+    ]
+   },
+   "claude-opus-4-8": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     8
+    ]
+   },
+   "claude-opus-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-opus-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "opus",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   },
+   "claude-sonnet-4-6": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     4,
+     6
+    ]
+   },
+   "claude-sonnet-5": {
+    "default_effort": "high",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": false,
+    "upgrade": null,
+    "version": [
+     5
+    ]
+   },
+   "claude-sonnet-5-5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "sonnet",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     5
+    ]
+   }
+  },
+  "source": "release"
+ },
+ "codex": {
+  "efforts": [
+   "none",
+   "minimal",
+   "low",
+   "medium",
+   "high",
+   "xhigh",
+   "max",
+   "ultra"
+  ],
+  "families": {
+   "astra": 4,
+   "luna": 1,
+   "sol": 3,
+   "terra": 2
+  },
+  "fetched_at": "2026-10-14T08:54:28Z",
+  "models": {
+   "codex-auto-review": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": null,
+    "version": []
+   },
+   "gpt-5.5": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": "gpt-6.1-sol",
+    "version": [
+     5,
+     5
+    ]
+   },
+   "gpt-5.6-luna": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "luna",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-5.6-sol": {
+    "default_effort": "low",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-5.6-terra": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "terra",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     5,
+     6
+    ]
+   },
+   "gpt-6-astra": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "astra",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6-luna": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": "luna",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6-sol": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6
+    ]
+   },
+   "gpt-6.1-sol": {
+    "default_effort": "low",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max",
+     "ultra"
+    ],
+    "family": "sol",
+    "listed": true,
+    "upgrade": null,
+    "version": [
+     6,
+     1
+    ]
+   },
+   "gpt-reserve": {
+    "default_effort": "medium",
+    "efforts": [
+     "low",
+     "medium",
+     "high",
+     "xhigh",
+     "max"
+    ],
+    "family": null,
+    "listed": false,
+    "upgrade": null,
+    "version": []
+   }
+  },
+  "source": "release"
+ },
+ "generated_at": "2026-10-14T08:55:08Z",
+ "schema": 1
+}