claude-multiacc 2.0.59 → 2.0.61

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
 
 
@@ -1204,14 +1413,18 @@ def cmd_snapshot(args):
 
 
 def cmd_learn(args):
+    from mcp_mirror import scoped_snapshots
+
     try:
         with open(args.before, encoding="utf-8") as handle:
             before = json.load(handle)
     except (OSError, ValueError) as exc:
         raise RegistryError(f"snapshot {args.before}: {exc}") from exc
-    after = snapshot(args.provider, args.account_dir)
     with _Lock(args.root):
+        after = snapshot(args.provider, args.account_dir)
         target = _Target(args.root)
+        before, after = scoped_snapshots(before, after, args.name, load_overlay(args.root),
+                                         "local" if target.replica else None)
         changes = _learn_into(target.section, before, after)
         if changes:
             target.save()
@@ -1251,8 +1464,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:
@@ -1306,7 +1523,8 @@ def build_parser():
     p = modes.add_parser("learn")
     p.add_argument("--account-dir", required=True)
     p.add_argument("--before", required=True)
-    p.add_argument("--project", help="accepted for the shim's sake; every changed project is mirrored")
+    p.add_argument("--name", help="mirror only this stock command's server, including project approvals")
+    p.add_argument("--project", help="accepted for the shim; --name applies across project entries")
 
     p = modes.add_parser("import-local")
     p.add_argument("--owner", required=True)
@@ -1330,7 +1548,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.59",
+  "version": "2.0.61",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
     "test:core": "bash tests/run-tests.sh && npm run test:selector && python3 tests/test_shim_path.py",
     "test:selector": "python3 -m unittest discover -s tests -p 'test_selector*.py'",
-    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 tests/test_mcp_registry.py && python3 tests/test_mcp_oauth.py && npm run test:codex-settings",
+    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 -m unittest discover -s tests -p 'test_mcp_*.py' && npm run test:codex-settings",
     "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
     "test:commands": "python3 tests/test_packaged_commands.py"
   },