memgres 0.9.0__tar.gz → 0.10.0__tar.gz

{memgres-0.9.0 → memgres-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.9.0
+Version: 0.10.0
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.9.0 → memgres-0.10.0}/memgres/_version.py

@@ -8,4 +8,4 @@ here at release; nowhere else carries the number.
 PEP 440: a ``.devN`` suffix marks an unreleased build ahead of the last tag.
 """
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"

{memgres-0.9.0 → memgres-0.10.0}/memgres/admin.py

@@ -353,7 +353,8 @@ def create_namespace(conn, p: Principal, *, owner_user_id: str, name: str,
 
 def edit_namespace(conn, p: Principal, *, namespace_id: str,
                    description: Optional[str] = None,
-                   instruction: Optional[str] = None) -> dict:
+                   instruction: Optional[str] = None,
+                   name: Optional[str] = None) -> dict:
     """Amend a namespace's description or routing instruction.
 
     `create_namespace` is an idempotent upsert that ignores conflicts, so
@@ -363,19 +364,92 @@ def edit_namespace(conn, p: Principal, *, namespace_id: str,
     """
     require_namespace_admin(conn, p, namespace_id)
     identity.edit_namespace(conn, namespace_id, description=description,
-                            instruction=instruction)
-    return {"namespace_id": namespace_id}
+                            instruction=instruction, name=name)
+    out = {"namespace_id": namespace_id}
+    if name is not None:
+        out["name"] = name
+        out["warning"] = ("renamed — anyone addressing it by the old name now "
+                          "gets 'no such namespace'. Ids and aliases still work")
+    return out
+
+
+def require_namespace_owner(conn, p: Principal, namespace_id: str) -> None:
+    """Owner-or-superadmin, a tier narrower than `require_namespace_admin`.
+
+    For the acts that dispose of the namespace itself rather than work inside
+    it. An admin MEMBER was given authority over the contents; giving away
+    somebody else's namespace is not part of that, and the difference only
+    matters here — which is why this is its own check rather than a flag.
+    """
+    require_namespace_admin(conn, p, namespace_id)      # ceiling + scope + exists
+    if p.is_admin:
+        return
+    if identity.namespace_owner(conn, namespace_id) != p.user_id:
+        raise Forbidden("only the owner (or a superadmin) may do this")
 
 
 def add_member(conn, p: Principal, *, namespace_id: str, user_id: str,
                permission: str = "read") -> dict:
-    """Share a namespace with another user — cross-tenant, so superadmin only."""
-    require_superadmin(p)
+    """Share a namespace with another user.
+
+    Authorized per-NAMESPACE, not deployment-wide. It used to demand superadmin,
+    on the reasoning that sharing reaches across tenants — but the thing being
+    shared is the caller's OWN namespace, and requiring the deployment's root
+    for that made "let a colleague into my cabinet" an operator ticket. What it
+    still demands is an admin-ceiling credential for that namespace, so a
+    read-only or differently-scoped token cannot hand out access.
+    """
+    require_namespace_admin(conn, p, namespace_id)
     identity.add_member(conn, namespace_id, user_id, permission)
     return {"namespace_id": namespace_id, "user_id": user_id,
             "permission": permission}
 
 
+def remove_member(conn, p: Principal, *, namespace_id: str, user_id: str) -> dict:
+    """Un-share a namespace. `removed: false` means they were not a member.
+
+    The other half of `add_member`, and its absence was the sharpest gap in this
+    control plane: access could be granted and never taken back except by
+    revoking every token the person held, which cuts them off from everything
+    rather than from this.
+    """
+    require_namespace_admin(conn, p, namespace_id)
+    return {"namespace_id": namespace_id, "user_id": user_id,
+            "removed": identity.remove_member(conn, namespace_id, user_id)}
+
+
+def transfer_namespace(conn, p: Principal, *, namespace_id: str,
+                       new_owner_user_id: str,
+                       keep_previous_owner: Optional[str] = "admin") -> dict:
+    """Hand a namespace to another account — owner or superadmin.
+
+    The outgoing owner stays behind as an `admin` member unless
+    `keep_previous_owner` is null. Defaulting to keeping them is the safer
+    footing: the alternative is a single call that removes the caller from a
+    namespace whose contents they may be the only one who knows.
+    """
+    require_namespace_owner(conn, p, namespace_id)
+    return identity.transfer_namespace(
+        conn, namespace_id, new_owner_user_id,
+        keep_previous_owner=keep_previous_owner)
+
+
+def set_disabled(conn, p: Principal, *, user_id: str, disabled: bool) -> dict:
+    """Switch an account off, or back on. Every token it holds stops at once.
+
+    Offboarding as ONE act. Doing it by revoking tokens one at a time is a loop
+    that has to be complete to be correct, and nothing stops a new token being
+    issued afterwards. Reversible and destructive of nothing — authorship,
+    namespaces and memberships all survive, which is what makes it usable for
+    "gone for now" as well as "gone".
+    """
+    require_manage_users(p)
+    _require_target_is_plain_user(conn, p, user_id,
+                                  "disabling an account" if disabled
+                                  else "re-enabling an account")
+    return identity.set_disabled(conn, user_id, disabled)
+
+
 def list_namespaces(conn, p: Principal, *, owner_user_id: Optional[str] = None,
                     limit: Optional[int] = None, offset: int = 0) -> List[dict]:
     """Deployment-wide namespace inventory.
@@ -407,6 +481,27 @@ def list_spaces(conn, p: Principal) -> List[dict]:
 
 # ─── tokens ──────────────────────────────────────────────────────────────────
 
+def _unreachable_warning(conn, user_id: str,
+                         namespace_id: Optional[str]) -> Optional[str]:
+    """Warn when a credential is about to be scoped to a namespace its owner
+    cannot reach.
+
+    Scoping is not granting: reach comes from ownership or membership, and a
+    token pinned to a namespace the account is not in is perfectly valid and
+    reaches nothing. The person enrols, everything answers "no namespace", and
+    it reads as a broken server rather than an unfinished provisioning. A
+    warning rather than a refusal, because issuing the credential first and
+    adding the membership after is a legitimate order.
+    """
+    if not namespace_id:
+        return None
+    if identity.reaches(conn, user_id, namespace_id) is not None:
+        return None
+    return ("that user cannot reach this namespace yet, so the token will be "
+            "valid and see NOTHING — add them with memory_admin_add_member "
+            "(or hand the namespace over) before they try to use it")
+
+
 def issue_token(conn, p: Principal, *, user_id: str,
                 namespace_id: Optional[str] = None, permission: str = "write",
                 label: str = "", expires_days: Optional[int] = None,
@@ -426,10 +521,14 @@ def issue_token(conn, p: Principal, *, user_id: str,
     expires_at = None
     if expires_days:
         expires_at = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=expires_days)
+    warning = _unreachable_warning(conn, user_id, namespace_id)
     secret, tid = identity.issue_token(conn, user_id, namespace_id=namespace_id,
                                        permission=permission, label=label,
                                        expires_at=expires_at)
-    return deliver_secret(secret, tid, sink_dir)
+    out = deliver_secret(secret, tid, sink_dir)
+    if warning:
+        out["warning"] = warning
+    return out
 
 
 def deliver_secret(secret: str, token_id: str, sink_dir: str) -> dict:
@@ -472,6 +571,9 @@ def create_enrollment(conn, p: Principal, *, user_id: str,
                    "for a meeting link — it is single-use and short-lived. They "
                    "generate their own token, put it in their client's config, "
                    "and call memory_enroll with this key.")
+    warning = _unreachable_warning(conn, user_id, namespace_id)
+    if warning:
+        out["warning"] = warning
     return out
 
 

{memgres-0.9.0 → memgres-0.10.0}/memgres/identity.py

@@ -24,6 +24,7 @@ resolve a space before every operation.
 
 from __future__ import annotations
 
+import datetime as dt
 import hashlib
 import hmac
 import os
@@ -189,16 +190,22 @@ def resolve(conn, cfg, secret: Optional[str], *, touch: bool = True) -> Principa
                 "SELECT t.id, t.user_id, t.namespace_id, t.permission, "
                 "       (t.revoked_at IS NOT NULL) AS revoked, "
                 "       (t.expires_at IS NOT NULL AND t.expires_at <= now()) AS expired, "
-                "       u.role "
+                "       u.role, (u.disabled_at IS NOT NULL) AS disabled "
                 "FROM token t JOIN app_user u ON u.id = t.user_id "
                 "WHERE t.token_hash=%s", (h,))
             row = cur.fetchone()
             if row is not None:
-                tid, uid, nsid, perm, revoked, expired, role = row
+                tid, uid, nsid, perm, revoked, expired, role, disabled = row
                 if revoked:
                     raise AuthError("token revoked")
                 if expired:
                     raise AuthError("token expired")
+                if disabled:
+                    # Checked HERE, on the credential, rather than at each door:
+                    # an account that is off has to be off for every token it
+                    # holds and every one it could still be issued, and the only
+                    # place all of those meet is authentication.
+                    raise AuthError("this account is disabled")
                 if touch:
                     cur.execute("UPDATE token SET last_used_at=now() WHERE id=%s",
                                 (tid,))
@@ -742,7 +749,8 @@ def list_users(conn, *, role: Optional[str] = None, limit: Optional[int] = None,
     if role is not None and role not in SERVICE_ROLES:
         raise ValueError(f"bad role: {role}")
     sql = ("SELECT id, name, description, role, can_create_namespace, "
-           "created_at, email, full_name, department, position FROM app_user")
+           "created_at, email, full_name, department, position, "
+           "disabled_at FROM app_user")
     args: list = []
     if role is not None:
         sql += " WHERE role=%s"                # backed by app_user_role_idx
@@ -755,13 +763,17 @@ def list_users(conn, *, role: Optional[str] = None, limit: Optional[int] = None,
         sql += " OFFSET %s"
         args.append(offset)
     cols = ["id", "name", "description", "role", "can_create_namespace",
-            "created_at", *PROFILE_FIELDS]
+            "created_at", *PROFILE_FIELDS, "disabled_at"]
     with conn.cursor() as cur:
         cur.execute(sql, args)
         out = []
         for r in cur.fetchall():
             d = dict(zip(cols, r))
             d["id"] = str(d["id"])
+            # Both, deliberately: `disabled` is what a caller branches on, and
+            # `disabled_at` answers "since when", which is the question that
+            # follows every time the first one is true.
+            d["disabled"] = d["disabled_at"] is not None
             out.append(d)
         return out
 
@@ -822,12 +834,81 @@ def revoke_superadmin(conn, user_id: str, *, demote_to: str = "user") -> None:
         cur.execute("UPDATE app_user SET role=%s WHERE id=%s", (demote_to, user_id))
 
 
+def set_disabled(conn, user_id: str, disabled: bool) -> dict:
+    """Turn an account off (or back on). Reversible, and destroys nothing.
+
+    Anti-lockout, in the same spirit as `revoke_superadmin`: the last ACTIVE
+    superadmin cannot be switched off, because nobody would be left who could
+    switch it back on. Recovery from such a lockout would mean editing the
+    database by hand.
+    """
+    with conn.cursor() as cur:
+        cur.execute("SELECT role, disabled_at IS NOT NULL FROM app_user WHERE id=%s",
+                    (_as_uuid(user_id),))
+        row = cur.fetchone()
+        if row is None:
+            raise SpaceNotFound(f"no such user {user_id}")
+        role, already = row
+        if bool(already) == bool(disabled):
+            return {"user_id": str(user_id), "disabled": bool(disabled),
+                    "unchanged": True}
+        if disabled and role == "superadmin":
+            cur.execute("SELECT count(*) FROM app_user WHERE role='superadmin' "
+                        "AND disabled_at IS NULL")
+            if int(cur.fetchone()[0]) <= 1:
+                raise AuthError("cannot disable the last active superadmin")
+        cur.execute("UPDATE app_user SET disabled_at = %s WHERE id=%s",
+                    (None if not disabled else dt.datetime.now(dt.timezone.utc),
+                     _as_uuid(user_id)))
+    return {"user_id": str(user_id), "disabled": bool(disabled)}
+
+
 # How many namespaces one account may own. Not a business rule — a bound, so a
 # self-service deployment cannot be turned into an INSERT loop by anyone holding
 # a well-formed token.
 MAX_NAMESPACES_PER_USER = 50
 
 
+def _require_name_free(cur, owner_user_id: str, name: str, *,
+                       except_namespace_id: Optional[str] = None,
+                       upsert: bool = False) -> None:
+    """Refuse a name that would be unaddressable for `owner_user_id`.
+
+    Two ways that happens, and they are the same failure seen from two sides: an
+    ALIAS of theirs already means something else (so the namespace could not be
+    reached by its own name, and their existing calls would silently keep
+    resolving elsewhere), or they already OWN a namespace by that name.
+
+    Extracted from `create_namespace` because renaming and transferring hit the
+    identical wall — and a check that lives at only one of three doors is the
+    kind of duplication this codebase keeps paying for.
+    """
+    cur.execute("SELECT namespace_id FROM namespace_alias "
+                "WHERE user_id=%s AND alias=%s", (owner_user_id, name))
+    if cur.fetchone() is not None:
+        raise SpaceAmbiguous(
+            f"'{name}' is already one of that user's aliases — the namespace "
+            "could not be addressed by its own name, and their existing calls "
+            "using it would keep resolving elsewhere. Drop the alias or choose "
+            "another name")
+    if upsert:
+        # `create_namespace` is an idempotent upsert BY DESIGN: calling it again
+        # with the same name returns the existing id rather than failing, which
+        # is what makes provisioning scripts re-runnable. Only renaming and
+        # transferring must refuse the collision, because for them there is no
+        # "the one you meant" to return.
+        return
+    sql = "SELECT id FROM namespace WHERE owner_user_id=%s AND name=%s"
+    args = [owner_user_id, name]
+    if except_namespace_id is not None:
+        sql += " AND id <> %s"
+        args.append(_as_uuid(except_namespace_id))
+    cur.execute(sql, args)
+    if cur.fetchone() is not None:
+        raise SpaceAmbiguous(
+            f"that account already owns a namespace called '{name}'")
+
+
 def create_namespace(conn, owner_user_id: str, name: str, *,
                      description: str = "", instruction: str = "") -> str:
     """Create (or return the existing) namespace ``name`` owned by the user.
@@ -841,14 +922,7 @@ def create_namespace(conn, owner_user_id: str, name: str, *,
     codebase keeps paying for.
     """
     with conn.cursor() as cur:
-        cur.execute("SELECT namespace_id FROM namespace_alias "
-                    "WHERE user_id=%s AND alias=%s", (owner_user_id, name))
-        if cur.fetchone() is not None:
-            raise SpaceAmbiguous(
-                f"'{name}' is already one of that user's aliases — the new "
-                "namespace could not be addressed by its own name, and their "
-                "existing calls using it would keep resolving elsewhere. Drop "
-                "the alias or choose another name")
+        _require_name_free(cur, owner_user_id, name, upsert=True)
         cur.execute("SELECT count(*) FROM namespace WHERE owner_user_id=%s",
                     (owner_user_id,))
         if cur.fetchone()[0] >= MAX_NAMESPACES_PER_USER:
@@ -966,8 +1040,25 @@ def add_member(conn, namespace_id: str, user_id: str, permission: str = "read")
 
 
 def edit_namespace(conn, namespace_id: str, *, description: Optional[str] = None,
-                   instruction: Optional[str] = None) -> None:
+                   instruction: Optional[str] = None,
+                   name: Optional[str] = None) -> None:
+    """Amend a namespace. `name` renames it — checked against the OWNER's other
+    namespaces and aliases, since that is who the name has to stay addressable
+    for. Anyone addressing it by the old name gets "no such namespace" from then
+    on; ids and aliases are unaffected."""
     sets, params = [], []
+    if name is not None:
+        if not name.strip():
+            raise ValueError("a namespace name cannot be blank")
+        with conn.cursor() as cur:
+            cur.execute("SELECT owner_user_id FROM namespace WHERE id=%s",
+                        (_as_uuid(namespace_id),))
+            row = cur.fetchone()
+            if row is None:
+                raise SpaceNotFound(f"no such namespace {namespace_id}")
+            _require_name_free(cur, str(row[0]), name,
+                               except_namespace_id=namespace_id)
+        sets.append("name=%s"); params.append(name)
     if description is not None:
         sets.append("description=%s"); params.append(description)
     if instruction is not None:
@@ -979,6 +1070,93 @@ def edit_namespace(conn, namespace_id: str, *, description: Optional[str] = None
         cur.execute(f"UPDATE namespace SET {', '.join(sets)} WHERE id=%s", params)
 
 
+def remove_member(conn, namespace_id: str, user_id: str) -> bool:
+    """Take a shared namespace away again. False if they were not a member.
+
+    Takes effect on the next call: reach is computed per request from the member
+    table, never cached. A token that was SCOPED to this namespace is not
+    revoked — it simply stops reaching anything, which is the same state as a
+    token scoped to a namespace that was never shared. Revoking it as well is
+    the caller's decision, not a side effect of un-sharing.
+    """
+    with conn.cursor() as cur:
+        cur.execute("SELECT owner_user_id FROM namespace WHERE id=%s",
+                    (_as_uuid(namespace_id),))
+        row = cur.fetchone()
+        if row is None:
+            raise SpaceNotFound(f"no such namespace {namespace_id}")
+        if str(row[0]) == str(user_id):
+            # Ownership is not a membership row, so deleting one would report
+            # success and change nothing — the owner would keep full access and
+            # whoever asked would believe they had removed it.
+            raise AuthError(
+                "that user OWNS this namespace — ownership is not a membership "
+                "and cannot be removed. Transfer the namespace instead")
+        cur.execute("DELETE FROM namespace_member WHERE namespace_id=%s "
+                    "AND user_id=%s RETURNING user_id",
+                    (_as_uuid(namespace_id), _as_uuid(user_id)))
+        return cur.fetchone() is not None
+
+
+def namespace_owner(conn, namespace_id: str) -> Optional[str]:
+    with conn.cursor() as cur:
+        cur.execute("SELECT owner_user_id FROM namespace WHERE id=%s",
+                    (_as_uuid(namespace_id),))
+        row = cur.fetchone()
+        return str(row[0]) if row else None
+
+
+def transfer_namespace(conn, namespace_id: str, new_owner_user_id: str, *,
+                       keep_previous_owner: Optional[str] = "admin") -> dict:
+    """Hand a namespace to somebody else.
+
+    `keep_previous_owner` leaves the outgoing owner behind as a member at that
+    permission (default `admin`), and defaults to doing so for a reason: without
+    it, one call removes the caller from a namespace they may be the only person
+    who knows the contents of, and nothing in the reply would have warned them.
+    Pass None for a clean hand-off.
+
+    The new owner's stale membership row, if any, is dropped — ownership already
+    grants more than any membership can, and leaving a `read` row behind means a
+    later transfer silently demotes them.
+    """
+    if keep_previous_owner is not None and keep_previous_owner not in _RANK:
+        raise ValueError(f"bad permission: {keep_previous_owner}")
+    with conn.cursor() as cur:
+        cur.execute("SELECT owner_user_id, name FROM namespace WHERE id=%s "
+                    "FOR UPDATE", (_as_uuid(namespace_id),))
+        row = cur.fetchone()
+        if row is None:
+            raise SpaceNotFound(f"no such namespace {namespace_id}")
+        old_owner, name = str(row[0]), row[1]
+        if old_owner == str(new_owner_user_id):
+            return {"namespace_id": str(namespace_id), "owner_user_id": old_owner,
+                    "unchanged": True}
+        cur.execute("SELECT 1 FROM app_user WHERE id=%s",
+                    (_as_uuid(new_owner_user_id),))
+        if cur.fetchone() is None:
+            raise SpaceNotFound(f"no such user {new_owner_user_id}")
+        # The receiving account has its own names and aliases, and (owner, name)
+        # is unique: without this the transfer dies on a constraint violation
+        # rather than on an explanation.
+        _require_name_free(cur, str(new_owner_user_id), name,
+                           except_namespace_id=namespace_id)
+        cur.execute("DELETE FROM namespace_member WHERE namespace_id=%s AND "
+                    "user_id=%s", (_as_uuid(namespace_id), _as_uuid(new_owner_user_id)))
+        cur.execute("UPDATE namespace SET owner_user_id=%s WHERE id=%s",
+                    (_as_uuid(new_owner_user_id), _as_uuid(namespace_id)))
+        if keep_previous_owner is not None:
+            cur.execute(
+                "INSERT INTO namespace_member (namespace_id, user_id, permission) "
+                "VALUES (%s, %s, %s) ON CONFLICT (namespace_id, user_id) "
+                "DO UPDATE SET permission=EXCLUDED.permission",
+                (_as_uuid(namespace_id), _as_uuid(old_owner), keep_previous_owner))
+    return {"namespace_id": str(namespace_id),
+            "owner_user_id": str(new_owner_user_id),
+            "previous_owner_user_id": old_owner,
+            "previous_owner_permission": keep_previous_owner}
+
+
 def list_spaces(conn, user_id: str) -> List[dict]:
     """Every namespace the user can reach: owned + shared, with flags."""
     aliases = list_aliases(conn, user_id)

{memgres-0.9.0 → memgres-0.10.0}/memgres/mcp_server.py

@@ -160,7 +160,7 @@ TOOL_VISIBILITY = {
     "memory_admin_list_tokens": ("identity", "can_manage_users"),
     "memory_admin_revoke_token": ("identity", "can_manage_users"),
     "memory_admin_set_role": ("identity", "can_administer_deployment"),
-    "memory_admin_add_member": ("identity", "can_administer_deployment"),
+    "memory_admin_set_disabled": ("identity", "can_manage_users"),
     "memory_admin_count_orphans": ("identity", "can_administer_deployment"),
     "memory_admin_adopt_orphans": ("identity", "can_administer_deployment"),
     # per-namespace admin: any namespace OWNER qualifies, so no deployment-wide
@@ -168,6 +168,13 @@ TOOL_VISIBILITY = {
     # ceiling, since the effective permission is membership ∧ ceiling
     "memory_admin_edit_namespace": ("identity", "has_admin_ceiling"),
     "memory_admin_list_members": ("identity", "has_admin_ceiling"),
+    "memory_admin_add_member": ("identity", "has_admin_ceiling"),
+    "memory_admin_remove_member": ("identity", "has_admin_ceiling"),
+    "memory_admin_transfer_namespace": ("identity", "has_admin_ceiling"),
+    "memory_admin_list_requests": ("identity", "has_admin_ceiling"),
+    "memory_admin_decide_access": ("identity", "has_admin_ceiling"),
+    # asking is not administering — anyone with an account may
+    "memory_request_access": ("identity",),
 }
 
 
@@ -782,6 +789,21 @@ def build_server(cfg: Optional[Config] = None):
         out.update({"permission": permission, "namespace_id": nsid})
         return out
 
+    @mcp.tool()
+    def memory_request_access(space_id: str, permission: str = "read",
+                              ctx: Context = None) -> dict:
+        """Ask the owner of a namespace to let you in.
+
+        The push side of sharing needs somebody to know your user id; this is
+        the pull side, for when you know a namespace exists and want in. You
+        need its id — the answer deliberately cannot tell a namespace you cannot
+        reach from one that does not exist, so ids come from a person, not from
+        browsing. `already_reachable` means you are in it already."""
+        with pool.connection() as conn, conn.transaction():
+            return admin.request_access(conn, _principal(conn, _token(ctx)),
+                                        namespace_id=space_id,
+                                        permission=permission)
+
     @mcp.tool()
     def memory_list_tokens(ctx: Context = None) -> List[dict]:
         """List your tokens (metadata only — never the secret)."""
@@ -922,15 +944,20 @@ def build_server(cfg: Optional[Config] = None):
         def memory_admin_edit_namespace(space_id: str,
                                         description: Optional[str] = None,
                                         instruction: Optional[str] = None,
+                                        name: Optional[str] = None,
                                         ctx: Context = None) -> dict:
-            """Amend a namespace's description or routing instruction. Creating
-            it again will not: that call ignores conflicts, so this is the only
-            way to correct the text agents route by."""
+            """Amend a namespace's description, routing instruction, or NAME.
+            Creating it again will not: that call ignores conflicts, so this is
+            the only way to correct the text agents route by.
+
+            Renaming is addressed by id and checked against the owner's other
+            namespaces and aliases. Callers using the old name get "no such
+            namespace" from then on; ids and aliases keep working."""
             with pool.connection() as conn, conn.transaction():
                 return admin.edit_namespace(
                     conn, _principal(conn, _token(ctx)),
                     namespace_id=space_id, description=description,
-                    instruction=instruction)
+                    instruction=instruction, name=name)
 
         @mcp.tool()
         def memory_admin_count_orphans(ctx: Context = None) -> dict:
@@ -959,12 +986,83 @@ def build_server(cfg: Optional[Config] = None):
                                     permission: str = "read",
                                     ctx: Context = None) -> dict:
             """Share a namespace with another user at read | write | admin.
-            Superadmin only — it grants access across tenants."""
+            Yours to give: the owner of a namespace (or a superadmin) may share
+            it, with an admin-ceiling credential for it. Re-adding an existing
+            member changes their permission."""
             with pool.connection() as conn, conn.transaction():
                 return admin.add_member(conn, _principal(conn, _token(ctx)),
                                         namespace_id=space_id, user_id=user_id,
                                         permission=permission)
 
+        @mcp.tool()
+        def memory_admin_remove_member(space_id: str, user_id: str,
+                                       ctx: Context = None) -> dict:
+            """Take a shared namespace away again. `removed: false` means they
+            were not a member.
+
+            Effective immediately — reach is recomputed on every call. A token
+            they hold that was SCOPED to this namespace keeps existing and stops
+            reaching anything; revoke it separately if that is what you meant.
+            The OWNER cannot be removed this way: ownership is not a membership,
+            so hand the namespace over instead."""
+            with pool.connection() as conn, conn.transaction():
+                return admin.remove_member(conn, _principal(conn, _token(ctx)),
+                                           namespace_id=space_id, user_id=user_id)
+
+        @mcp.tool()
+        def memory_admin_transfer_namespace(
+                space_id: str, new_owner_user_id: str,
+                keep_previous_owner: Optional[str] = "admin",
+                ctx: Context = None) -> dict:
+            """Hand a namespace to another account — owner or superadmin only.
+
+            The outgoing owner stays behind as a member at
+            `keep_previous_owner` (default `admin`); pass null for a clean
+            hand-off, knowing that this removes them from a namespace whose
+            contents they may be the only one who knows. Refused if the new
+            owner already owns — or aliases — a namespace by the same name,
+            since the name has to stay addressable for whoever holds it."""
+            with pool.connection() as conn, conn.transaction():
+                return admin.transfer_namespace(
+                    conn, _principal(conn, _token(ctx)), namespace_id=space_id,
+                    new_owner_user_id=new_owner_user_id,
+                    keep_previous_owner=keep_previous_owner)
+
+        @mcp.tool()
+        def memory_admin_list_requests(space_id: str,
+                                       ctx: Context = None) -> List[dict]:
+            """Pending requests to join a namespace you administer — who asked,
+            for what permission, when."""
+            with pool.connection() as conn:
+                out = admin.list_requests(conn, _principal(conn, _token(ctx)),
+                                          namespace_id=space_id)
+            return _iso(out, "created_at")
+
+        @mcp.tool()
+        def memory_admin_decide_access(request_id: str, approve: bool = True,
+                                       ctx: Context = None) -> dict:
+            """Approve or deny a request to join. Approving adds them as a
+            member at the permission they asked for — the same act as
+            `memory_admin_add_member`, reached from their side."""
+            with pool.connection() as conn, conn.transaction():
+                admin.decide_access(conn, _principal(conn, _token(ctx)),
+                                    request_id=request_id, approve=approve)
+            return {"request_id": request_id, "approved": approve}
+
+        @mcp.tool()
+        def memory_admin_set_disabled(user_id: str, disabled: bool = True,
+                                      ctx: Context = None) -> dict:
+            """Switch an account off, or back on.
+
+            Offboarding in one act: every token it holds stops authenticating at
+            once, and so does any token issued to it later. Nothing is
+            destroyed — authorship, namespaces and memberships all survive, and
+            re-enabling restores the account as it was. The last ACTIVE
+            superadmin cannot be switched off."""
+            with pool.connection() as conn, conn.transaction():
+                return admin.set_disabled(conn, _principal(conn, _token(ctx)),
+                                          user_id=user_id, disabled=disabled)
+
         @mcp.tool()
         def memory_admin_list_members(space_id: str,
                                       ctx: Context = None) -> List[dict]:

memgres-0.10.0/memgres/migrations/0022_user_disabled.sql

@@ -0,0 +1,12 @@
+-- Turning an account off without destroying it (schema v23).
+--
+-- Offboarding had no operation. The only way to stop someone was to revoke
+-- their tokens one at a time — a loop over a list that has to be complete to be
+-- correct, with nothing preventing a fresh token being issued a minute later.
+-- A person leaving is not a person being deleted: their authorship stays, their
+-- namespaces stay, and coming back should not mean being re-provisioned.
+--
+-- A timestamp rather than a boolean: "when did this account stop working" is
+-- the question actually asked afterwards, and a bool cannot answer it. NULL =
+-- active, which makes every existing row correct without a backfill.
+ALTER TABLE app_user ADD COLUMN IF NOT EXISTS disabled_at timestamptz;

{memgres-0.9.0 → memgres-0.10.0}/memgres/schema.py

@@ -18,7 +18,7 @@ from pathlib import Path
 from .config import Config
 
 # The version this build migrates the database TO (the latest migration it carries).
-SCHEMA_VERSION = 22
+SCHEMA_VERSION = 23
 
 # The compatibility FLOOR: the schema version of the most recent backward-
 # INCOMPATIBLE migration — one that changed the shape/semantics old code relied on