loopable / api /agent_directory.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
b2aa446 verified
Raw History Blame
12.3 kB
"""The workspace directory tool: the people of the caller's own workspace and their access.
R84: the list never crosses tenants. `users._tenant_accounts` is the one tenant wall.
R92: each entry carries role, modules, databases, row limits and hidden fields.
R108(c): a field or database the CALLER cannot see is never named.
Every entry is a whitelist projection: no password hash, salt, MFA secret, recovery code,
session epoch, phone, email or avatar leaves this module.
"""
import logging
from core import perm_scope, perms, users
_LOG = logging.getLogger(__name__)
HIDDEN_FIELD = "a hidden field"
LIMITED = "Limited by your access"
REFUSAL = "The directory of your workspace could not be read. Try again in a moment."
NOT_FOUND = "No one by that name uses Loopable in your workspace."
# Shell.tsx opens these workspace modules for every signed-in account.
_WORKSPACE_MODULES = ("Sheet", "Table", "App")
_OPS = {
"eq": "is", "neq": "is not", "contains": "contains", "doesNotContain": "does not contain",
"gt": "is more than", "gte": "is at least", "lt": "is less than", "lte": "is at most",
"within": "is within", "isAnyOf": "is one of", "isNoneOf": "is none of",
"hasAnyOf": "has any of", "hasAllOf": "has all of", "hasNoneOf": "has none of",
}
SCHEMA = {
"type": "object",
"description": ("List the people of your own workspace, with each person's role, what they "
"can open, their row limits and hidden fields."),
"properties": {"username": {"type": "string"}},
"additionalProperties": False,
}
_ADMITTED = {"who uses loopable here", "who uses loopable", "who uses loopable in my workspace",
"who is in my workspace", "who are the people in my workspace"}
def admits(question):
"""True for a directory question, so the router can skip its database match."""
import re
return " ".join(re.findall(r"\w+", str(question).casefold())) in _ADMITTED
class DirectoryUnavailable(ValueError):
"""The registry or the caller's own account could not be read. Fail closed."""
def _tenant(session):
want = str(getattr(session, "tenant", "") or "").strip().lower()
own = str((getattr(session, "user", None) or {}).get("tenant") or "").strip().lower()
if not want or (own and own != want):
raise DirectoryUnavailable(REFUSAL)
return want
def _accounts(session):
"""`[(username, record)]` of the caller's tenant. Refuses when the caller is not among them."""
tenant = _tenant(session)
accounts = users._tenant_accounts(tenant)
me = str(getattr(session, "uname", "") or "").strip().lower()
if not me or me not in {str(n).strip().lower() for n, _ in accounts}:
# An empty list is a failed read or a revoked caller. Never an answer.
raise DirectoryUnavailable(REFUSAL)
return sorted(accounts, key=lambda pair: str(pair[0]).lower())
def _lend(session):
from core import user_tables
return user_tables.lend_defs(session.runtime)
def _databases(session, st):
"""`[{key, label}]`: every database this tenant governs, topics and its own `ut_*` tables."""
from core import registry, user_tables
ut = user_tables.nav_entries(viewer=session.uname, is_admin=True, st=st)
topics = list(registry.governable_modules().values())
return perms.tenant_governable_modules(session.runtime, topics, ut_entries=ut)
def _modules(session):
"""`[{key, label}]`: the app surfaces this tenant is provisioned for."""
return [m for m in perms.governable_surface_modules()
if perms.tenant_has_module(session.runtime, m["key"])]
def _fields(principal, key, st):
"""`{field_key: label}` this principal may see on `key`, or None when unreadable."""
try:
rows = perm_scope.scoped_fields(principal, key, st=st)
except Exception: # noqa: BLE001
return None
return {str(f["key"]): str(f.get("label") or f["key"])
for f in rows or () if isinstance(f, dict) and f.get("key")}
def _name_field(seen, key):
"""The label of `key` when the caller can see it, else the hidden placeholder."""
return (seen or {}).get(str(key)) or HIDDEN_FIELD
def _value(leaf):
if isinstance(leaf.get("values"), list):
return ", ".join(str(v) for v in leaf["values"])
if leaf.get("op") == "between":
return f"{leaf.get('value')} and {leaf.get('value2')}"
return str(leaf.get("value") if leaf.get("value") is not None else "")
def _leaf_sentence(leaf, seen):
"""One plain sentence for a filter leaf, or None when it names a field the caller cannot see."""
col = str(leaf.get("colId") or "")
if col not in (seen or {}):
return None
rhs = leaf.get("rhs")
if isinstance(rhs, dict):
if str(rhs.get("colId") or "") not in seen:
return None
target = seen[str(rhs["colId"])]
else:
target = _value(leaf)
op = str(leaf.get("op") or "")
label = seen[col]
if op == "isEmpty":
return f"{label} is empty"
if op == "isNotEmpty":
return f"{label} is not empty"
if op == "between":
return f"{label} is between {target}"
if op in _OPS:
return f"{label} {_OPS[op]} {target}".rstrip()
return f"{label} has a ranking condition"
def _node_sentence(node, seen):
if not isinstance(node, dict):
return None
if isinstance(node.get("children"), list):
parts = [_node_sentence(child, seen) for child in node["children"]]
if not parts or any(p is None for p in parts):
return None
joiner = " or " if node.get("conj") == "or" else " and "
return "(" + joiner.join(parts) + ")" if len(parts) > 1 else parts[0]
return _leaf_sentence(node, seen)
def _filter_sentences(tree, seen, label):
"""Plain sentences for one stored filter tree. A leaf the caller cannot see reads LIMITED."""
if isinstance(tree, dict):
nodes = tree.get("nodes") if isinstance(tree.get("nodes"), list) else []
conj = "or" if tree.get("conj") == "or" else "and"
else:
nodes, conj = (tree if isinstance(tree, list) else []), "and"
parts = [_node_sentence(n, seen) for n in nodes]
if not parts:
return []
prefix = f"{label}: " if label else ""
if conj == "or":
if any(p is None for p in parts):
return [LIMITED]
return [prefix + " or ".join(parts)]
return [LIMITED if p is None else prefix + p for p in parts]
#: The Odoo field a legacy team scope narrows, and Odoo's own name for it (R66).
_TEAM_TABLE, _TEAM_FIELD, _TEAM_LABEL = "ut_odoo_orders", "team", "Sales team"
def _team_label(st, caller):
"""The caller-visible team label, with Odoo's name for an absent field."""
try:
from core import user_tables
fields = (user_tables.get_one(_TEAM_TABLE, st) or {}).get("fields") or ()
field = next((f for f in fields if isinstance(f, dict) and f.get("key") == _TEAM_FIELD), {})
if field:
return _name_field(_fields(caller, _TEAM_TABLE, st), _TEAM_FIELD)
return _TEAM_LABEL
except Exception: # noqa: BLE001
return _TEAM_LABEL
def _legacy_limits(rec, st=None, caller=None):
out = []
labels = users.allowed_bus_labels(rec)
if "All" not in labels and labels:
out.append(f"{_team_label(st, caller)} is " + " or ".join(labels))
agent = perms.scope_agent(rec)
if agent:
out.append(f"Sales agent is {agent}")
return out
def _entry(session, uname, rec, ctx):
"""The whitelist projection of one colleague, as the caller is allowed to see it."""
principal = users._public(uname, rec)
st, caller = ctx["st"], session.user
admin = perms.is_admin(principal)
modules = list(_WORKSPACE_MODULES) + [m["label"] for m in ctx["modules"]
if admin or perm_scope.nav_may_open(principal, m["key"], st=st)]
named, unnamed, limits, hidden = [], 0, [], []
for db in ctx["databases"]:
key = db["key"]
if not (admin or perm_scope.may_read(principal, key, st=st)):
continue
seen = ctx["seen"].get(key)
if seen is None:
# The caller cannot read this database: never name it, count it.
unnamed += 1
seen = {}
else:
named.append(db["label"])
if admin:
continue
stored = perm_scope.entry(principal, key) or {}
if perm_scope.is_migrated(principal) and stored.get("filter"):
limits.extend(_filter_sentences(stored["filter"], seen,
db["label"] if key in ctx["seen"] else ""))
theirs = _fields(principal, key, st)
keys = [str(k) for k in (stored.get("hiddenFields") or ()) if k]
if theirs is not None:
keys += [k for k in seen if k not in theirs and k not in keys]
hidden.extend(_name_field(seen, k) for k in keys)
if unnamed:
named.append(f"{unnamed} database{'' if unnamed == 1 else 's'} you cannot open")
if not admin and not perm_scope.is_migrated(principal):
limits = _legacy_limits(rec, st, caller) + limits
return {"username": str(rec.get("username_original") or uname),
"name": str(rec.get("name") or uname),
"role": "Administrator" if admin else "Member",
"modules": modules, "databases": named,
"rowLimits": limits, "hiddenFields": hidden}
def _context(session):
st = _lend(session)
databases = [d for d in _databases(session, st) if isinstance(d, dict) and d.get("key")]
caller = session.user
seen = {}
for db in databases:
if perm_scope.may_read(caller, db["key"], st=st):
seen[db["key"]] = _fields(caller, db["key"], st) or {}
return {"st": st, "databases": databases, "modules": _modules(session), "seen": seen}
def people(session):
"""Every active account of the caller's own workspace. Raises DirectoryUnavailable."""
try:
accounts = _accounts(session)
ctx = _context(session)
return [_entry(session, n, rec, ctx) for n, rec in accounts]
except DirectoryUnavailable:
raise
except Exception as exc: # noqa: BLE001
_LOG.warning("Workspace directory read failed (%s)", type(exc).__name__)
raise DirectoryUnavailable(REFUSAL) from exc
def _colleague(session, username):
"""One same-tenant account, or None when nobody matches. Raises DirectoryUnavailable."""
want = str(username or "").strip().casefold()
if not want:
return None
try:
accounts = _accounts(session)
match = [(n, rec) for n, rec in accounts
if want in {str(n).casefold(), str(rec.get("username_original") or "").casefold(),
str(rec.get("name") or "").strip().casefold()}]
if not match:
return None
return _entry(session, match[0][0], match[0][1], _context(session))
except DirectoryUnavailable:
raise
except Exception as exc: # noqa: BLE001
_LOG.warning("Workspace directory lookup failed (%s)", type(exc).__name__)
raise DirectoryUnavailable(REFUSAL) from exc
def colleague(session, username):
"""One same-tenant active account by username or name, or None. Never crosses tenants."""
try:
return _colleague(session, username)
except DirectoryUnavailable:
return None
def workspace_people(session, args):
"""The `workspace_people` tool: the caller's workspace roster, or one person in it."""
args = args if isinstance(args, dict) else {}
want = str(args.get("username") or "").strip()
try:
if want:
one = _colleague(session, want)
if one is None:
return {"people": [], "note": NOT_FOUND}
return {"people": [one]}
return {"people": people(session)}
except DirectoryUnavailable:
return {"ok": False, "refused": REFUSAL}
TOOLS = ({"name": "workspace_people", "schema": SCHEMA, "fn": workspace_people, "effect": "read"},)