Spaces:
Running on CPU Upgrade
Running on CPU Upgrade
Download api/agent_directory.py from fsanyoto/runloopable: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/agent_directory.py
- Command line
-
hf download hf://spaces/fsanyoto/runloopable/api/agent_directory.py
-
curl -L -o agent_directory.py https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/agent_directory.py
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"},) | |