memgres 0.13.2__tar.gz → 0.14.0__tar.gz

{memgres-0.13.2 → memgres-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.13.2
+Version: 0.14.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.13.2 → memgres-0.14.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.13.2"
+__version__ = "0.14.0"

{memgres-0.13.2 → memgres-0.14.0}/memgres/identity.py

@@ -1006,6 +1006,10 @@ def create_own_namespace(conn, principal: Principal, name: str, *,
     had worked. Creation is now something you ask for, which makes a typo an
     error rather than a place — and gives the `can_create_namespace` right a
     single point to be enforced at.
+
+    Unlike :func:`create_namespace`, which the provisioning doors call and which
+    hands back an existing space of the same name so a script can be re-run,
+    this door REFUSES that name: whoever called it asked for a new space.
     """
     if principal.user_id is None:
         if not principal.provisional:
@@ -1027,6 +1031,21 @@ def create_own_namespace(conn, principal: Principal, name: str, *,
     if not can_create_namespace(conn, principal):
         raise AuthError("you may not create namespaces — ask an admin to create "
                         "one for you or share theirs")
+    # `create_namespace` is an idempotent upsert, which is right for the
+    # provisioning doors (a script must be re-runnable) and wrong for this one.
+    # Here the caller is an agent or a person who said "create", and being
+    # handed a space they already had — with `description` and `instruction`
+    # silently NOT applied, because the upsert does nothing on conflict — looks
+    # exactly like success. The refusal names the space, so a retry after a
+    # dropped connection is answered rather than left to guess.
+    with conn.cursor() as cur:
+        cur.execute("SELECT id FROM namespace WHERE owner_user_id=%s AND name=%s",
+                    (principal.user_id, name))
+        row = cur.fetchone()
+    if row is not None:
+        raise SpaceAmbiguous(
+            f"you already own a namespace called '{name}' ({row[0]}) — write to "
+            f"it, or pick another name")
     # the alias collision and the per-account cap are enforced in
     # `create_namespace`, so every door gets them
     return create_namespace(conn, principal.user_id, name,

{memgres-0.13.2 → memgres-0.14.0}/memgres/mcp_server.py

@@ -718,7 +718,11 @@ def build_server(cfg: Optional[Config] = None):
         """Create a namespace of your own. Nothing creates one implicitly, so a
         mistyped `space` is an error rather than a new empty space your write
         silently lands in. `description` says what belongs here and `instruction`
-        tells an agent how to use it. Needs the right to create namespaces."""
+        tells an agent how to use it. Needs the right to create namespaces.
+
+        A name you already own is refused, and the error names that space: this
+        never hands you an existing namespace as if it were new. To change what
+        an existing one says, edit it instead of creating it again."""
         with pool.connection() as conn, conn.transaction():
             nsid = identity.create_own_namespace(
                 conn, _principal(conn, _token(ctx)), name,

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/people.py

@@ -9,6 +9,13 @@ Who sees what:
   administrator's account, and only a superadmin hands out roles;
 * **someone you share a space with** — who they are (name, department,
   position) and what they wrote in the spaces you can both read;
+* **what someone wrote** — the activity chart and the list of recent edits —
+  is only ever shown where the VIEWER can read too: a superadmin reads every
+  space, everyone else (a user_manager included) only the spaces they are in.
+  so the PAGE never displays records from a space the viewer cannot open.
+  That is a rule about this page, not a containment guarantee about the role:
+  an administrator who can mint a token FOR someone can read what that someone
+  reads, which docs/TENANCY.md states outright;
 * **anyone else** — not found. There is no directory for ordinary users.
 
 Activity is writes only, taken from memory history: what someone created,
@@ -93,6 +100,38 @@ def activity(conn, user_id: str, *, spaces: Optional[list]) -> dict:
     }
 
 
+RECENT_EDITS = 30
+
+
+def recent_edits(conn, user_id: str, *, spaces: Optional[list]) -> list:
+    """The person's latest changes, newest first — record, space, kind, when.
+    ``spaces=None`` means every space (a superadmin looking)."""
+    params: list = [user_id]
+    where = ""
+    if spaces is not None:
+        if not spaces:
+            return []
+        where = " AND m.namespace = ANY(%s::text[])"
+        params.append(spaces)
+    params.append(RECENT_EDITS)
+    with conn.cursor() as cur:
+        cur.execute(
+            "SELECT h.created_at, h.op, m.id::text, m.namespace, m.path::text, m.title, n.name "
+            "FROM memory_history h JOIN memory m ON m.id = h.memory_id "
+            "JOIN namespace n ON n.id::text = m.namespace "
+            "WHERE h.author_user_id = %s" + where + " ORDER BY h.created_at DESC, h.id DESC LIMIT %s", params)
+        return [{"at": at, "op": op, "record_id": rid, "space_id": ns, "path": path, "title": title or "",
+                 "space": sname} for at, op, rid, ns, path, title, sname in cur.fetchall()]
+
+
+def _viewer_scope(conn, viewer) -> Optional[list]:
+    """The spaces whose contents this viewer may see: every one for a superadmin
+    (its role reads them all), otherwise its own."""
+    if viewer.user_id is None or viewer.role == "superadmin":
+        return None
+    return _reachable(conn, viewer.user_id)
+
+
 def _account(cur, user_id: str):
     cur.execute("SELECT id, name, full_name, email, department, position, role, "
                 "disabled_at IS NOT NULL, created_at, can_create_namespace FROM app_user WHERE id = %s",
@@ -127,7 +166,8 @@ def profile(conn, viewer, target_id: str, *, providers: dict) -> dict:
                         (together,))
             spaces = [{"id": i, "name": n} for i, n in cur.fetchall()]
         return {"view": "colleague", "person": person, "shared_spaces": spaces,
-                "activity": activity(conn, str(uid), spaces=together)}
+                "activity": activity(conn, str(uid), spaces=together),
+                "recent": recent_edits(conn, str(uid), spaces=together)}
 
     # who holds authority on the server is not a colleague's business
     person.update({"role": role, "email": email, "disabled": bool(disabled), "created_at": created,
@@ -141,6 +181,7 @@ def profile(conn, viewer, target_id: str, *, providers: dict) -> dict:
     # tokens and sign-in methods are not theirs to see (admin.list_tokens
     # refuses the same thing).
     may_manage = is_self or viewer.role == "superadmin" or role not in ADMIN_ROLES
+    scope = _viewer_scope(conn, viewer)
     out = {
         "view": "self" if is_self else "admin",
         "person": person,
@@ -149,7 +190,8 @@ def profile(conn, viewer, target_id: str, *, providers: dict) -> dict:
         "signins": admission.identities(conn, str(uid), providers) if may_manage else None,
         "tokens": tokens.list_own(conn, str(uid)) if may_manage else None,
         "sessions": live_sessions,
-        "activity": activity(conn, str(uid), spaces=None if is_service_admin else [s["id"] for s in spaces]),
+        "activity": activity(conn, str(uid), spaces=scope),
+        "recent": recent_edits(conn, str(uid), spaces=scope),
     }
     if not is_self:
         # what this administrator may do to this account, by the rules that
@@ -275,6 +317,86 @@ def edit(conn, p, user_id: str, changes: dict) -> None:
     _guard(lambda: admin.edit_user(conn, p, user_id=user_id, **fields))
 
 
+def create_person(conn, p, fields: dict) -> str:
+    """An account made by an administrator — for someone who will sign in later
+    (the email is how their first sign-in finds it) or for a service that only
+    ever uses tokens. It gets no spaces and no rights: those are separate acts."""
+    clean = {}
+    for k in ("name", "full_name", "email", "department", "position"):
+        v = fields.get(k)
+        if v is None:
+            continue
+        if not isinstance(v, str):
+            raise Refused(422, f"{k} must be text")
+        v = v.strip()
+        if len(v) > 200:
+            raise Refused(422, f"{k} is longer than 200 characters")
+        if v:
+            clean[k] = v
+    if "email" in clean:
+        from .spaces import Refused as SpaceRefused, normalize_email
+        try:
+            clean["email"] = normalize_email(clean["email"])
+        except SpaceRefused as e:
+            raise Refused(422, str(e)) from None
+        with conn.cursor() as cur:
+            cur.execute("SELECT 1 FROM app_user WHERE lower(email) = lower(%s)", (clean["email"],))
+            if cur.fetchone():
+                raise Refused(409, "another account already has this email")
+    if not (clean.get("full_name") or clean.get("email") or clean.get("name")):
+        raise Refused(422, "give the account a name or an email")
+    name = clean.pop("name", None) or clean.get("email") or clean.get("full_name")
+    return _guard(lambda: admin.create_user(conn, p, name=name, **clean))
+
+
+def set_can_create_spaces(conn, p, user_id: str, allowed: bool) -> None:
+    user_id = _uuid(user_id)
+    _guard(lambda: admin.set_can_create_namespace(conn, p, user_id=user_id, allowed=bool(allowed)))
+
+
+def issue_for(conn, p, user_id: str, *, label: str, permission: str,
+              namespace_id: Optional[str], expires_days: int) -> dict:
+    """A token for someone else — the same shape a person gets for themselves
+    (read or write, always expiring, optionally one of their spaces), minted by
+    an administrator for an account that cannot do it itself: a service, or
+    someone who has not signed in yet. The secret is shown once, to the
+    administrator, who hands it over — the same exemption from
+    ``MEMGRES_TOKEN_SINK`` the self-service door takes, and for the same reason:
+    the sink keeps secrets out of *agent* transcripts, and the reader here is a
+    human looking at a dialog that says "copy it now".
+
+    The cap on live tokens is the account's, not the issuer's: an administrator
+    minting for someone cannot fill the table past what that person could fill
+    it to themselves."""
+    from .tokens import EXPIRY_CHOICES, MAX_LABEL, MAX_LIVE_TOKENS, PERMISSIONS
+    user_id = _uuid(user_id)
+    label = (label or "").strip()
+    if len(label) > MAX_LABEL:
+        raise Refused(422, f"the label is longer than {MAX_LABEL} characters")
+    if permission not in PERMISSIONS:
+        raise Refused(422, "access must be read or write")
+    if expires_days not in EXPIRY_CHOICES:
+        raise Refused(422, f"expiry must be one of {', '.join(map(str, EXPIRY_CHOICES))} days")
+    if namespace_id:
+        namespace_id = _uuid(namespace_id)
+        if identity.reaches(conn, user_id, namespace_id) is None:
+            raise Refused(422, "that person cannot open this space — add them to it first")
+    with conn.cursor() as cur:
+        cur.execute("SELECT 1 FROM app_user WHERE id = %s", (user_id,))
+        if cur.fetchone() is None:
+            raise Refused(404, "not found")
+        cur.execute("SELECT count(*) FROM token WHERE user_id = %s AND revoked_at IS NULL "
+                    "AND (expires_at IS NULL OR expires_at > now())", (user_id,))
+        if cur.fetchone()[0] >= MAX_LIVE_TOKENS:
+            raise Refused(409, f"that account already has {MAX_LIVE_TOKENS} active tokens — "
+                               "revoke some it no longer uses")
+    out = _guard(lambda: admin.issue_token(conn, p, user_id=user_id, namespace_id=namespace_id or None,
+                                           permission=permission, label=label, expires_days=expires_days,
+                                           defer_delivery=True))
+    return {"id": out["id"], "token": out["secret"], "permission": permission,
+            "namespace_id": namespace_id or None, "expires_days": expires_days}
+
+
 # ─── record history (for authors) ────────────────────────────────────────────
 def record_history(store, principal, space_id: str, record_id: str) -> list:
     """Who changed a record and when — the way into a person's profile from
@@ -324,6 +446,26 @@ def mount(app, cfg, pool, panel, providers, make_store) -> None:
         _run(lambda conn: edit(conn, p, user_id, changes))
         return {"user_id": user_id}
 
+    @app.post("/ui/api/admin/people", status_code=201)
+    def new_person(request: Request, fields: dict = Body(...)):
+        p = control_principal(_admin(request, changing=True))
+        return {"id": _run(lambda conn: create_person(conn, p, fields))}
+
+    @app.post("/ui/api/admin/people/{user_id}/can-create-spaces")
+    def can_create(user_id: str, request: Request, allowed: bool = Body(..., embed=True)):
+        p = control_principal(_admin(request, changing=True))
+        _run(lambda conn: set_can_create_spaces(conn, p, user_id, allowed))
+        return {"user_id": user_id, "can_create_namespace": bool(allowed)}
+
+    @app.post("/ui/api/admin/people/{user_id}/tokens", status_code=201)
+    def token_for(user_id: str, request: Request, label: str = Body("", embed=True),
+                  permission: str = Body("write", embed=True),
+                  namespace_id: Optional[str] = Body(None, embed=True),
+                  expires_days: int = Body(90, embed=True)):
+        p = control_principal(_admin(request, changing=True))
+        return _run(lambda conn: issue_for(conn, p, user_id, label=label, permission=permission,
+                                           namespace_id=namespace_id, expires_days=expires_days))
+
     @app.post("/ui/api/admin/people/{user_id}/role")
     def set_role(user_id: str, request: Request, role: str = Body(..., embed=True)):
         p = control_principal(_admin(request, changing=True))

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/routes.py

@@ -149,8 +149,11 @@ def mount(app, cfg, pool, make_store, *, oidc_fetch=None) -> None:
 
     def _session_view(s) -> dict:
         pending = 0
+        can_create = False
         with pool.connection() as conn:
             me = sessions.profile(conn, s.user_id)
+            if s.user_id is not None:
+                can_create = identity.can_create_namespace(conn, sessions.control_principal(s))
             if s.role in identity.ADMIN_ROLES:
                 with conn.cursor() as cur:
                     cur.execute("SELECT count(*) FROM signin_request WHERE status = 'pending'")
@@ -168,8 +171,12 @@ def mount(app, cfg, pool, make_store, *, oidc_fetch=None) -> None:
                 "memory": s.user_id is not None,
                 "tokens": s.user_id is not None,
                 "admin": s.role in identity.ADMIN_ROLES,
+                # the right to make a space of one's own, as the control plane reads it
+                "create_space": s.user_id is not None and can_create,
             },
             "locales": list(LOCALES),
+            # where agents connect, for the token dialogs (the panel cannot work it out)
+            "mcp_url": cfg.mcp_public_url or None,
         }
 
     def _client_key(request: Request) -> str:

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/spaces.py

@@ -7,7 +7,9 @@ second copy of them:
 * members, invitations and requests of a space — its administrators (the owner,
   an ``admin`` member, a superadmin);
 * handing the space to someone else — the owner or a superadmin;
-* asking to join, or leaving — the person themselves.
+* asking to join, or leaving — the person themselves;
+* making a space of your own — anyone the deployment granted that right
+  (``can_create_namespace``, a switch on the person's page).
 
 **An invitation opens a space, never the server.** Inviting an address that
 already has an account adds that account at once. Otherwise the invitation waits
@@ -265,6 +267,29 @@ def transfer(conn, p, space_id: str, user_id: str, *, keep_me: bool) -> dict:
         raise Refused(409, str(e)) from None
 
 
+def create_own(conn, p, *, name: str, description: str) -> dict:
+    """A space of one's own. The right is the control plane's
+    (``can_create_namespace``); everything else — the name's shape, the cap on
+    how many one account may own — is enforced where namespaces are created."""
+    name = (name or "").strip()
+    if not name:
+        raise Refused(422, "a space needs a name")
+    if len(name) > 100:
+        raise Refused(422, "the name is longer than 100 characters")
+    description = (description or "").strip()[:500]
+    if p.user_id is None:
+        raise Refused(409, "the administrator token has no account to own a space")
+    try:
+        nsid = identity.create_own_namespace(conn, p, name, description=description)
+    except identity.SpaceAmbiguous as e:      # a name you already own, or the cap
+        raise Refused(409, str(e)) from None
+    except identity.AuthError as e:
+        raise Refused(403, str(e)) from None
+    except ValueError as e:
+        raise Refused(422, str(e)) from None
+    return {"id": nsid, "name": name}
+
+
 # ─── asking to join ──────────────────────────────────────────────────────────
 def my_request(conn, user_id: str, space_id: str) -> dict:
     """The caller's own request for a space, if any — answered from the caller's
@@ -399,6 +424,12 @@ def mount(app, cfg, pool, panel) -> None:
             except Refused as e:
                 raise HTTPException(e.status, str(e))
 
+    @app.post("/ui/api/spaces", status_code=201)
+    def make_space(request: Request, name: str = Body(..., embed=True),
+                   description: str = Body("", embed=True)):
+        s = panel["changing"](request)
+        return _run(lambda conn: create_own(conn, control_principal(s), name=name, description=description))
+
     @app.get("/ui/api/spaces/{space_id}/members")
     def members(space_id: str, request: Request):
         p = control_principal(panel["session"](request))

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/static/app.css

@@ -489,3 +489,24 @@ a.person:hover { color: var(--focus); box-shadow: inset 0 -1px 0 var(--focus); }
 @media (prefers-reduced-motion: reduce) { .spinner, .search.busy::before { animation-duration: 2.4s; } }
 /* the results header — the query and × — stays put while the list scrolls under it */
 .results > .res-head { position: sticky; top: -14px; z-index: 2; margin: -14px -14px 0; padding: 14px 14px 10px; background: var(--panel); border-radius: 14px 14px 0 0; box-shadow: 0 1px 0 var(--line-soft); }
+
+/* people directory pages, recent edits, switches, connection how-to */
+.pager { display: flex; align-items: center; justify-content: flex-end; gap: 8px; margin-top: 10px; flex-wrap: wrap; }
+.pager .note { margin-right: auto; }
+.recent { display: grid; gap: 2px; }
+.rrow { display: grid; grid-template-columns: 76px minmax(0, 1fr) auto; gap: 10px; align-items: baseline; padding: 7px 8px; border-radius: 8px; text-decoration: none; color: var(--text); }
+.rrow:hover { background: var(--panel-2); }
+.rrow .op { font: 500 11px var(--mono); color: var(--muted); }
+.rrow .rt { min-width: 0; }
+.rrow .rt b { display: block; font-weight: 500; color: var(--bright); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.rrow .rt small { display: flex; align-items: center; gap: 6px; font: 11.5px var(--mono); color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.rrow time { font-size: 12px; color: var(--muted); white-space: nowrap; }
+.switch { display: inline-flex; align-items: center; gap: 8px; cursor: pointer; font-size: 13px; color: var(--text); }
+.switch input { width: 16px; height: 16px; accent-color: var(--admin); }
+.howto .steps { margin: 0; padding-left: 1.3em; display: grid; gap: 10px; }
+.howto .steps li { line-height: 1.55; }
+.howto .snips { margin: 8px 0 6px; }
+.howto pre.code { margin-top: 6px; }
+@media (max-width: 760px) { .rrow { grid-template-columns: minmax(0, 1fr) auto; } .rrow .op { display: none; } }
+.every-link.make { color: var(--focus); text-decoration-color: rgba(79,214,242,.4); }
+.every-link.make:hover { text-decoration-color: var(--focus); }

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/static/js/account.js

@@ -2,7 +2,7 @@
 
 import { get, patch } from "./api.js";
 import { fillLanguageSelect, t } from "./i18n.js";
-import { activityCard, spacesCard } from "./people.js";
+import { activityCard, recentCard, spacesCard } from "./people.js";
 import { $, esc, toast } from "./ui.js";
 
 export function renderAccount(root, ctx) {
@@ -35,7 +35,7 @@ export function renderAccount(root, ctx) {
     <div class="pane" id="acc-more"></div>`;
   get(`/people/${encodeURIComponent(me.id)}`).then((data) => {
     const more = $("#acc-more", box);
-    if (more) more.innerHTML = activityCard(data.activity, { note: t("act.noteSelf") }) + spacesCard(data.spaces);
+    if (more) more.innerHTML = activityCard(data.activity, { note: t("act.noteSelf") }) + recentCard(data.recent, { note: t("recent.noteSelf") }) + spacesCard(data.spaces);
   }).catch(() => {});
   const select = $("#acc-lang", box);
   fillLanguageSelect(select, me.ui_language || "auto");

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/static/js/admin.js

@@ -93,29 +93,30 @@ async function renderRequests(box, ctx) {
 }
 
 // ─── the directory ───────────────────────────────────────────────────────────
+const PAGE = 25;
+
 async function renderPeople(box) {
-  box.innerHTML = `<div class="card"><div class="card-h"><h3>${esc(t("adm.people"))}</h3><span class="note" id="pp-total"></span></div>
+  box.innerHTML = `<div class="card"><div class="card-h"><h3>${esc(t("adm.people"))}</h3>
+        <button class="btn adminbtn small" id="pp-new">${esc(t("adm.newPerson"))}</button></div>
       <div class="filter" style="max-width:none;margin-bottom:12px"><svg width="12" height="12" viewBox="0 0 16 16" aria-hidden="true"><circle cx="7" cy="7" r="4.6" fill="none" stroke="#707aa0" stroke-width="1.6"/><path d="m10.4 10.4 3.4 3.4" stroke="#707aa0" stroke-width="1.6" stroke-linecap="round"/></svg>
         <input id="pp-q" type="search" autocomplete="off" placeholder="${esc(t("people.searchPh"))}" aria-label="${esc(t("people.searchPh"))}"></div>
       <div class="x"><table id="pp-table"><tbody><tr><td class="note">…</td></tr></tbody></table></div>
-      <div class="row" id="pp-more" style="justify-content:center;margin-top:10px" hidden><button class="btn small">${esc(t("viz.showMore"))}</button></div>
+      <div class="pager" id="pp-pager"></div>
     </div>
     <p class="note">${esc(t("adm.peopleNote"))}</p>`;
-  const PAGE = 50;
-  let rows = [], seq = 0, timer = null;
-  const load = async (append = false) => {
+  let offset = 0, total = 0, seq = 0, timer = null;
+  const load = async () => {
     const my = ++seq, q = $("#pp-q", box).value.trim();
     let got;
     try {
-      got = await get(`/admin/people?limit=${PAGE}&offset=${append ? rows.length : 0}&q=${encodeURIComponent(q)}`);
+      got = await get(`/admin/people?limit=${PAGE}&offset=${offset}&q=${encodeURIComponent(q)}`);
     } catch {
       if (my === seq) $("#pp-table", box).innerHTML = `<tbody><tr><td class="note">${esc(t("err.network"))}</td></tr></tbody>`;
       return;
     }
     if (my !== seq) return;
-    rows = append ? rows.concat(got.people) : got.people;
-    $("#pp-total", box).textContent = t("adm.peopleCount", { n: got.total });
-    $("#pp-more", box).hidden = rows.length >= got.total;
+    total = got.total;
+    const rows = got.people;
     $("#pp-table", box).innerHTML = rows.length ? `<thead><tr>${["adm.col.person", "acc.role", "adm.col.signins", "adm.col.lastSignin", "adm.col.lastWrite", "tok.status"].map((k) => `<th>${esc(t(k))}</th>`).join("")}</tr></thead>
       <tbody>${rows.map((p) => `<tr>
         <td class="strong">${personLink(p.id, personName(p))}<small class="cell-sub">${esc([p.email, p.department].filter(Boolean).join(" · "))}</small></td>
@@ -125,8 +126,55 @@ async function renderPeople(box) {
         <td>${esc(p.last_write_at ? ago(p.last_write_at) : t("tok.never"))}</td>
         <td><span class="dot ${p.disabled ? "off" : "on"}"><i></i>${esc(t(p.disabled ? "people.disabled" : "people.active"))}</span></td>
       </tr>`).join("")}</tbody>` : `<tbody><tr><td class="note">${esc(t("people.noneFound"))}</td></tr></tbody>`;
+    const from = total ? offset + 1 : 0, to = offset + rows.length;
+    $("#pp-pager", box).innerHTML = `<span class="note">${esc(t("adm.range", { from: nf(from), to: nf(to), total: nf(total) }))}</span>
+      <button class="btn small quiet" data-page="-1" ${offset === 0 ? "disabled" : ""} aria-label="${esc(t("adm.prev"))}">‹ ${esc(t("adm.prev"))}</button>
+      <button class="btn small quiet" data-page="1" ${to >= total ? "disabled" : ""} aria-label="${esc(t("adm.next"))}">${esc(t("adm.next"))} ›</button>`;
   };
-  $("#pp-q", box).addEventListener("input", () => { clearTimeout(timer); timer = setTimeout(() => load(), 220); });
-  $("#pp-more button", box).onclick = () => load(true);
+  $("#pp-q", box).addEventListener("input", () => { clearTimeout(timer); timer = setTimeout(() => { offset = 0; load(); }, 220); });
+  $("#pp-pager", box).addEventListener("click", (e) => {
+    const b = e.target.closest("[data-page]");
+    if (!b || b.disabled) return;
+    offset = Math.max(0, offset + Number(b.dataset.page) * PAGE);
+    load();
+  });
+  $("#pp-new", box).onclick = () => newPersonDialog();
   await load();
 }
+
+function newPersonDialog() {
+  const veil = document.createElement("div");
+  veil.className = "veil";
+  const field = (k, label, type = "text") => `<div class="field"><label for="np-${k}">${esc(label)}</label><input id="np-${k}" type="${type}" maxlength="200"></div>`;
+  veil.innerHTML = `<form class="dialog" role="dialog" aria-modal="true" aria-labelledby="np-title">
+    <h3 id="np-title">${esc(t("adm.newPerson"))}</h3>
+    ${field("full_name", t("acc.name"))}
+    ${field("email", t("acc.email"), "email")}
+    <div class="two">${field("department", t("people.department"))}${field("position", t("people.position"))}</div>
+    <p class="note">${esc(t("adm.newPersonNote"))}</p>
+    <p class="err" id="np-err" role="alert" hidden></p>
+    <div class="row" style="justify-content:flex-end"><button type="button" class="btn quiet" data-x>${esc(t("common.cancel"))}</button>
+      <button type="submit" class="btn adminbtn">${esc(t("adm.create"))}</button></div>
+  </form>`;
+  document.body.append(veil);
+  const close = () => veil.remove();
+  veil.addEventListener("keydown", (e) => { if (e.key === "Escape") close(); });
+  veil.addEventListener("click", (e) => { if (e.target === veil || e.target.closest("[data-x]")) close(); });
+  $("#np-full_name", veil).focus();
+  $("form", veil).addEventListener("submit", async (e) => {
+    e.preventDefault();
+    const body = {};
+    for (const k of ["full_name", "email", "department", "position"]) body[k] = $("#np-" + k, veil).value.trim();
+    try {
+      const { id } = await post("/admin/people", body);
+      close();
+      toast(t("adm.created", { name: body.full_name || body.email }));
+      history.pushState(null, "", `/people?id=${encodeURIComponent(id)}`);
+      window.memgresPanel?.render?.();
+    } catch (ex) {
+      const err = $("#np-err", veil);
+      err.textContent = ex instanceof ApiError && ex.detail ? String(ex.detail) : t("err.save");
+      err.hidden = false;
+    }
+  });
+}

{memgres-0.13.2 → memgres-0.14.0}/memgres/web/static/js/memory.js

@@ -34,6 +34,9 @@ export async function renderMemory(root, ctx) {
   if (!target) { showEmpty(); return; }
   if (!m.space || m.space.id !== target.id || !m.graph) await openSpace(target);
   else { mountViz(); inspect(); }
+  // a link to one record (from a person's recent edits): open it where it is
+  const rec = new URLSearchParams(location.search).get("record");
+  if (rec && m.byRecord.has(rec)) select(m.byRecord.get(rec), { centre: true });
 }
 
 // The sidebar's list of spaces, on every page — not only while memory is open.
@@ -95,6 +98,46 @@ function forget(id) {
   else renderSpaceList();
 }
 
+// A space of your own — for whoever the deployment granted that right.
+function makeSpaceDialog() {
+  const veil = document.createElement("div");
+  veil.className = "veil";
+  veil.innerHTML = `<form class="dialog" role="dialog" aria-modal="true" aria-labelledby="ms-title">
+    <h3 id="ms-title">${esc(t("sp.make"))}</h3>
+    <div class="field"><label for="ms-name">${esc(t("sp.makeName"))}</label>
+      <input id="ms-name" maxlength="100" required placeholder="${esc(t("sp.makeNamePh"))}"></div>
+    <div class="field"><label for="ms-desc">${esc(t("sp.makeDesc"))}</label>
+      <input id="ms-desc" maxlength="500" placeholder="${esc(t("sp.makeDescPh"))}"></div>
+    <p class="note">${esc(t("sp.makeNote"))}</p>
+    <p class="err" id="ms-err" role="alert" hidden></p>
+    <div class="row" style="justify-content:flex-end"><button type="button" class="btn quiet" data-x>${esc(t("common.cancel"))}</button>
+      <button type="submit" class="btn primary">${esc(t("sp.makeGo"))}</button></div>
+  </form>`;
+  document.body.append(veil);
+  const close = () => veil.remove();
+  veil.addEventListener("keydown", (e) => { if (e.key === "Escape") close(); });
+  veil.addEventListener("click", (e) => { if (e.target === veil || e.target.closest("[data-x]")) close(); });
+  $("#ms-name", veil).focus();
+  $("form", veil).addEventListener("submit", async (e) => {
+    e.preventDefault();
+    const submit = $("button[type=submit]", veil);
+    submit.disabled = true;
+    try {
+      const made = await post("/spaces", { name: $("#ms-name", veil).value.trim(), description: $("#ms-desc", veil).value.trim() });
+      close();
+      toast(t("sp.made", { name: made.name }));
+      m.loaded = false;
+      $("#shell").classList.remove("drawer");
+      m.navigate(`/memory?space=${encodeURIComponent(made.id)}`);
+    } catch (ex) {
+      const err = $("#ms-err", veil);
+      err.textContent = ex instanceof ApiError && ex.detail ? String(ex.detail) : t("err.save");
+      err.hidden = false;
+      submit.disabled = false;
+    }
+  });
+}
+
 function openEverySpace() {
   const veil = document.createElement("div");
   veil.className = "veil";
@@ -247,6 +290,7 @@ function wireSidebar() {
     const x = e.target.closest("[data-forget]");
     if (x) { e.preventDefault(); e.stopPropagation(); forget(x.dataset.forget); return; }
     if (e.target.closest("[data-every]")) openEverySpace();
+    if (e.target.closest("[data-make]")) makeSpaceDialog();
   }, true);
   $("#space-filter").addEventListener("input", renderSpaceList);
 }
@@ -299,7 +343,8 @@ function renderSpaceList() {
   const role = visiting.length ? `<div class="sec-h visiting-h" title="${esc(t("every.groupWhy"))}"><span>${esc(t("every.group"))}</span></div>` + visiting.map((s) =>
     `<a class="spaceitem visiting" role="listitem" href="/memory?space=${encodeURIComponent(s.id)}" data-space="${esc(s.id)}" style="--c:${spaceColor(s)}" aria-current="${m.space?.id === s.id}" title="${esc(t("every.itemWhy", { name: s.name }))}">${hexIcon(spaceColor(s), true, 16)}<span class="nm">${esc(s.name)}</span><button class="forget" data-forget="${esc(s.id)}" aria-label="${esc(t("every.forget", { name: s.name }))}">×</button></a>`).join("") : "";
   const every = isSuper() ? `<button class="every-link" data-every>${esc(t("every.link"))}</button>` : "";
-  $("#spacelist").innerHTML = own + role + every;
+  const make = m.session?.can?.create_space ? `<button class="every-link make" data-make>${esc(t("sp.make"))}</button>` : "";
+  $("#spacelist").innerHTML = own + role + make + every;
   if (m.space) $("#mbar-space").innerHTML = `${hexIcon(spaceColor(m.space), false, 14)}${esc(m.space.name)}`;
 }