nonebot-plugin-onebot-luckperms 0.1.0__py3-none-any.whl

nonebot_plugin_onebot_luckperms/__init__.py

@@ -0,0 +1,127 @@
+import logging
+
+from nonebot.plugin import PluginMetadata
+
+from .core.registry import register_node
+from .core.models import ContextSet, PermissionNode
+from .core.context_provider import register_context_provider, ContextProvider
+from .storage import get_store
+from .adapter import set_resolver, require, require_any, require_all, get_context
+from .adapter.context import LPContext
+from .config import OBLPConfig, oblp_config
+
+logger = logging.getLogger("oblp")
+
+__version__ = "0.1.0"
+
+__plugin_meta__ = PluginMetadata(
+    name="nonebot-plugin-onebot-luckperms",
+    description="LuckPerms-style permission system for NoneBot2 + OneBot",
+    usage="Register nodes with register_node(), use require() in command matchers",
+    type="library",
+    homepage="https://github.com/XChen446/nonebot-plugin-onebot-luckperms",
+    config=OBLPConfig,
+    supported_adapters={"~onebot.v11"},
+)
+
+__all__ = [
+    "register_node",
+    "require",
+    "require_any",
+    "require_all",
+    "get_context",
+    "set_resolver",
+    "ContextSet",
+    "PermissionNode",
+    "oblp_config",
+    "get_store",
+    "LPContext",
+    "register_context_provider",
+    "ContextProvider",
+]
+
+_store_initialized = False
+
+
+def _register_builtin_nodes():
+    register_node("luckperms.*", "Access to all LuckPerms commands", default=True)
+    register_node("luckperms.help", "View LuckPerms help", default=False)
+    register_node("luckperms.info", "View LuckPerms info", default=False)
+    register_node("luckperms.sync", "Reload LuckPerms data", default=False)
+    register_node("luckperms.editor", "Open LuckPerms Web Editor", default=False)
+    register_node("luckperms.applyedits", "Apply Web Editor edits", default=False)
+    register_node("luckperms.check", "Check user permissions", default=False)
+    register_node("luckperms.tree", "View permission inheritance tree", default=False)
+    register_node("luckperms.user.info", "View user details", default=False)
+    register_node("luckperms.user.permission", "Manage user permissions", default=False)
+    register_node("luckperms.user.parent", "Manage user group membership", default=False)
+    register_node("luckperms.user.promote", "Promote user", default=False)
+    register_node("luckperms.user.demote", "Demote user", default=False)
+    register_node("luckperms.user.clear", "Clear user permissions", default=False)
+    register_node("luckperms.user.clone", "Clone user", default=False)
+    register_node("luckperms.user.create", "Create user", default=False)
+    register_node("luckperms.user.delete", "Delete user", default=False)
+    register_node("luckperms.user.list", "List all users", default=False)
+    register_node("luckperms.group.info", "View group details", default=False)
+    register_node("luckperms.group.permission", "Manage group permissions", default=False)
+    register_node("luckperms.group.parent", "Manage group inheritance", default=False)
+    register_node("luckperms.group.setweight", "Set group weight", default=False)
+    register_node("luckperms.group.setdisplayname", "Set group display name", default=False)
+    register_node("luckperms.group.clear", "Clear group permissions", default=False)
+    register_node("luckperms.group.rename", "Rename group", default=False)
+    register_node("luckperms.group.clone", "Clone group", default=False)
+    register_node("luckperms.group.listmembers", "List group members", default=False)
+    register_node("luckperms.group.create", "Create group", default=False)
+    register_node("luckperms.group.delete", "Delete group", default=False)
+    register_node("luckperms.group.list", "List all groups", default=False)
+
+
+_register_builtin_nodes()
+
+
+async def _init():
+    global _store_initialized
+
+    if _store_initialized:
+        return
+
+    from nonebot import get_plugin_config
+    from .config import OBLPConfig
+    from .storage import init_store
+    from .adapter.identity import set_resolver as _set_resolver, OneBotV11Resolver
+    from .commands import register_admin_commands
+    from .message import load_messages, _export_defaults
+
+    raw_cfg = get_plugin_config(OBLPConfig)
+
+    for field in raw_cfg.model_fields:
+        setattr(oblp_config, field, getattr(raw_cfg, field))
+
+    store_type = oblp_config.store_type
+    kwargs = {}
+    if store_type == "sqlite":
+        kwargs["db_path"] = oblp_config.sqlite_path
+    elif store_type == "redis":
+        kwargs["redis_url"] = oblp_config.redis_url
+
+    store = init_store(store_type, **kwargs)
+    await store.load_all()
+    _set_resolver(OneBotV11Resolver())
+    register_admin_commands()
+
+    await load_messages(oblp_config.message_file)
+    try:
+        await _export_defaults(oblp_config.message_file)
+    except Exception:
+        pass
+
+    _store_initialized = True
+    logger.info(f"OBLP initialized (store: {store_type})")
+
+
+try:
+    from nonebot import get_driver
+    driver = get_driver()
+    driver.on_startup(_init)
+except (ValueError, RuntimeError, ImportError):
+    logger.debug("NoneBot not initialized, OBLP will init on first use")

nonebot_plugin_onebot_luckperms/adapter/__init__.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from .identity import Identity, IdentityResolver, OneBotV11Resolver, set_resolver
+from .permission import require, require_any, require_all
+from .context import get_context, LPContext
+
+__all__ = [
+    "Identity",
+    "IdentityResolver",
+    "OneBotV11Resolver",
+    "set_resolver",
+    "require",
+    "require_any",
+    "require_all",
+    "get_context",
+    "LPContext",
+]

nonebot_plugin_onebot_luckperms/adapter/context.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import contextvars
+import time
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Any
+
+from ..core.models import User, QueryOptions, ContextSet
+
+
+@dataclass(frozen=True)
+class LPContext:
+    user: User
+    identity: "Identity"
+    query_options: QueryOptions
+    resolved_nodes: Dict[str, bool]
+    matched_node: Optional[str] = None
+    timestamp: float = field(default_factory=time.time)
+
+
+_lp_context: contextvars.ContextVar[Optional[LPContext]] = contextvars.ContextVar(
+    "oblp_context", default=None
+)
+
+
+def get_context() -> Optional[LPContext]:
+    return _lp_context.get()
+
+
+def set_context(ctx: Optional[LPContext]):
+    _lp_context.set(ctx)

nonebot_plugin_onebot_luckperms/adapter/identity.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Protocol
+
+from nonebot.adapters import Bot, Event
+
+logger = logging.getLogger("oblp")
+
+
+@dataclass
+class Identity:
+    user_id: str
+    platform: str
+    group_id: Optional[str] = None
+    role: str = "member"
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+class IdentityResolver(Protocol):
+    async def resolve(self, bot: Bot, event: Event) -> Identity:
+        ...
+
+
+_resolver: Optional[IdentityResolver] = None
+
+
+def set_resolver(resolver: IdentityResolver):
+    global _resolver
+    _resolver = resolver
+    logger.info(f"IdentityResolver set to {type(resolver).__name__}")
+
+
+def get_resolver() -> Optional[IdentityResolver]:
+    return _resolver
+
+
+class OneBotV11Resolver:
+    async def resolve(self, bot: Bot, event: Event) -> Identity:
+        from nonebot.adapters.onebot.v11 import GroupMessageEvent, PrivateMessageEvent
+
+        user_id = event.get_user_id()
+        group_id = None
+        role = "member"
+        platform = "onebot_v11"
+
+        if isinstance(event, GroupMessageEvent):
+            group_id = str(event.group_id)
+            if event.sender and event.sender.role:
+                role = event.sender.role
+        elif isinstance(event, PrivateMessageEvent):
+            platform = "onebot_v11_private"
+
+        if user_id in getattr(bot.config, "superusers", set()):
+            role = "superuser"
+
+        return Identity(
+            user_id=user_id,
+            platform=platform,
+            group_id=group_id,
+            role=role,
+            extra={"raw_event_name": event.get_event_name()},
+        )

nonebot_plugin_onebot_luckperms/adapter/permission.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, Set
+
+from nonebot.permission import Permission
+from nonebot.adapters import Bot, Event
+
+from ..core.models import ContextSet, QueryOptions, User, PermissionNode
+from ..core.registry import NodeRegistry
+from ..core.engine import PermissionEngine
+from ..core.cache import PermissionCache
+from ..core.context_provider import get_context_providers
+from ..config import oblp_config
+from ..storage import get_store
+from .identity import get_resolver, Identity
+from .context import LPContext, set_context
+
+logger = logging.getLogger("oblp")
+
+
+def _apply_default_nodes(user: User, identity: Identity) -> list:
+    """Apply default permission nodes based on the user's role from config."""
+    nodes = []
+    role_map = {
+        "owner": oblp_config.default_group_owner,
+        "admin": oblp_config.default_group_admin,
+        "member": oblp_config.default_group_member,
+        "superuser": oblp_config.superuser_inherit,
+    }
+    patterns = role_map.get(identity.role, [])
+    for pattern in patterns:
+        if pattern == "*":
+            nodes.append(PermissionNode(key="*", value=True))
+        elif pattern:
+            nodes.append(PermissionNode(key=pattern, value=True))
+    return nodes
+
+
+def _checker_factory(
+    node_keys: Set[str],
+    mode: str,
+    base_contexts: Optional[ContextSet] = None,
+):
+    async def checker(bot: Bot, event: Event) -> bool:
+        resolver = get_resolver()
+        store = get_store()
+        if resolver is None or store is None:
+            logger.warning("OBLP not initialized: no resolver or store")
+            return False
+
+        try:
+            identity: Identity = await resolver.resolve(bot, event)
+        except Exception as e:
+            logger.error(f"Failed to resolve identity: {e}")
+            return False
+
+        ctx = ContextSet.from_dict({
+            "platform": identity.platform,
+            "user_id": identity.user_id,
+            "role": identity.role,
+        })
+        if identity.group_id:
+            ctx = ctx.with_context("group_id", identity.group_id)
+
+        if base_contexts:
+            for k, v in base_contexts.data.items():
+                ctx = ctx.with_context(k, v)
+
+        # Call all registered third-party context providers
+        for provider in get_context_providers():
+            try:
+                extra = await provider(bot, event, ctx)
+                if extra:
+                    for k, v in extra.items():
+                        ctx = ctx.with_context(k, v)
+            except Exception:
+                logger.exception(f"ContextProvider {type(provider).__name__} error")
+
+        query_opts = QueryOptions(
+            mode="contextual",
+            contexts=ctx,
+            flags={"include_inherited", "resolve_inheritance"},
+        )
+
+        cache_key = PermissionCache.make_key(identity.user_id, ctx)
+        cached = PermissionCache.get(cache_key)
+        if cached is not None:
+            resolved = cached
+        else:
+            user = await store.get_user(identity.user_id)
+            if user is None:
+                user = User(user_id=identity.user_id)
+
+            default_nodes = _apply_default_nodes(user, identity)
+            resolved = await user.get_effective_nodes(store, query_opts, ctx)
+
+            for dn in default_nodes:
+                if dn.key not in resolved:
+                    resolved[dn.key] = dn.value
+
+            PermissionCache.set(cache_key, resolved)
+
+        matched_node = None
+        if mode == "any":
+            result = any(
+                PermissionEngine.check(resolved, nk)
+                for nk in node_keys
+            )
+            if result:
+                for nk in node_keys:
+                    if PermissionEngine.check(resolved, nk):
+                        matched_node = nk
+                        break
+        elif mode == "all":
+            result = all(
+                PermissionEngine.check(resolved, nk)
+                for nk in node_keys
+            )
+            if result:
+                matched_node = ",".join(node_keys)
+        else:
+            target = next(iter(node_keys))
+            result = PermissionEngine.check(resolved, target)
+            if result:
+                matched_node = target
+
+        lp_ctx = LPContext(
+            user=user if 'user' in dir() else User(user_id=identity.user_id),
+            identity=identity,
+            query_options=query_opts,
+            resolved_nodes=resolved,
+            matched_node=matched_node,
+        )
+        set_context(lp_ctx)
+
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                f"[oblp] User {identity.user_id} check {node_keys} "
+                f"in {ctx.to_dict()} -> {result}"
+            )
+
+        return result
+
+    return checker
+
+
+def require(node_key: str, contexts: Optional[ContextSet] = None) -> Permission:
+    return Permission(_checker_factory({node_key}, "single", contexts))
+
+
+def require_any(*node_keys: str, contexts: Optional[ContextSet] = None) -> Permission:
+    return Permission(_checker_factory(set(node_keys), "any", contexts))
+
+
+def require_all(*node_keys: str, contexts: Optional[ContextSet] = None) -> Permission:
+    return Permission(_checker_factory(set(node_keys), "all", contexts))

nonebot_plugin_onebot_luckperms/commands/__init__.py

@@ -0,0 +1,3 @@
+from .admin import register_admin_commands
+
+__all__ = ["register_admin_commands"]