supernote 0.4.0__tar.gz → 0.5.0__tar.gz

{supernote-0.4.0 → supernote-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.4.0
+Version: 0.5.0
 Summary: All-in-one toolkit for Supernote devices: parse notebooks, self-host services, access services
 Author-email: jya <jya@wizmy.net>, Allen Porter <allen.porter@gmail.com>
 License-Expression: Apache-2.0

{supernote-0.4.0 → supernote-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0"]
 
 [project]
 name = "supernote"
-version = "0.4.0"
+version = "0.5.0"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
 description = "All-in-one toolkit for Supernote devices: parse notebooks, self-host services, access services"

{supernote-0.4.0 → supernote-0.5.0}/supernote/cli/server.py

@@ -2,35 +2,29 @@
 
 import argparse
 import getpass
-import os
-
-import yaml
 
 from supernote.server import app as server_app
+from supernote.server.config import AuthConfig, ServerConfig
 from supernote.server.services.user import UserService
 
 
-def load_users(users_file):
-    if not os.path.exists(users_file):
-        return {"users": []}
-    with open(users_file, "r") as f:
-        return yaml.safe_load(f) or {"users": []}
-
-
-def save_users(data, users_file: str):
-    with open(users_file, "w") as f:
-        yaml.safe_dump(data, f, default_flow_style=False)
+def get_auth_config(config_dir: str | None) -> AuthConfig:
+    # Load base config
+    server_config = ServerConfig.load(config_dir)
+    return server_config.auth
 
 
-def list_users(users_file: str):
-    service = UserService(users_file)
+def list_users(config_dir: str | None):
+    config = get_auth_config(config_dir)
+    service = UserService(config)
     for user in service.list_users():
-        status = "active" if user.get("is_active", True) else "inactive"
-        print(f"{user['username']} ({status})")
+        status = "active" if user.is_active else "inactive"
+        print(f"{user.username} ({status})")
 
 
-def add_user(users_file: str, username: str, password: str | None = None):
-    service = UserService(users_file)
+def add_user(config_dir: str | None, username: str, password: str | None = None):
+    config = get_auth_config(config_dir)
+    service = UserService(config)
     if password is None:
         password = getpass.getpass(f"Password for {username}: ")
     if service.add_user(username, password):
@@ -39,8 +33,9 @@ def add_user(users_file: str, username: str, password: str | None = None):
         print(f"User '{username}' already exists.")
 
 
-def deactivate_user(users_file: str, username: str):
-    service = UserService(users_file)
+def deactivate_user(config_dir: str | None, username: str):
+    config = get_auth_config(config_dir)
+    service = UserService(config)
     if service.deactivate_user(username):
         print(f"User '{username}' deactivated.")
     else:
@@ -56,46 +51,42 @@ def add_parser(subparsers):
 
     # User management
     parser_user = subparsers.add_parser("user", help="User management commands")
-    parser_user.add_argument(
-        "--users-file",
-        type=str,
-        default="./config/users.yaml",
-        help="Path to users.yaml file",
-    )
     user_subparsers = parser_user.add_subparsers(dest="user_command")
 
     # user list
-    parser_user_list = user_subparsers.add_parser(
-        "list", help="List all users in users.yaml"
-    )
-    parser_user_list.set_defaults(func=lambda args: list_users(args.users_file))
+    parser_user_list = user_subparsers.add_parser("list", help="List all users")
+    parser_user_list.set_defaults(func=lambda args: list_users(args.config_dir))
 
     # user add
-    parser_user_add = user_subparsers.add_parser(
-        "add", help="Add a new user to users.yaml"
-    )
+    parser_user_add = user_subparsers.add_parser("add", help="Add a new user")
     parser_user_add.add_argument("username", type=str, help="Username to add")
     parser_user_add.add_argument(
         "--password", type=str, help="Password (if omitted, prompt interactively)"
     )
     parser_user_add.set_defaults(
-        func=lambda args: add_user(args.users_file, args.username, args.password)
+        func=lambda args: add_user(args.config_dir, args.username, args.password)
     )
 
     # user deactivate
     parser_user_deactivate = user_subparsers.add_parser(
-        "deactivate", help="Deactivate a user in users.yaml"
+        "deactivate", help="Deactivate a user"
     )
     parser_user_deactivate.add_argument(
         "username", type=str, help="Username to deactivate"
     )
     parser_user_deactivate.set_defaults(
-        func=lambda args: deactivate_user(args.users_file, args.username)
+        func=lambda args: deactivate_user(args.config_dir, args.username)
     )
 
 
 def main():
     parser = argparse.ArgumentParser(description="Supernote Server CLI")
+    parser.add_argument(
+        "--config-dir",
+        type=str,
+        default=None,
+        help="Path to configuration directory (default: config/)",
+    )
     subparsers = parser.add_subparsers(dest="command")
     add_parser(subparsers)
     args = parser.parse_args()

{supernote-0.4.0 → supernote-0.5.0}/supernote/server/__init__.py

@@ -3,10 +3,10 @@
 """
 
 from .app import create_app, run
-from .config import Config
+from .config import ServerConfig
 
 __all__ = [
     "create_app",
     "run",
-    "Config",
+    "ServerConfig",
 ]

{supernote-0.4.0 → supernote-0.5.0}/supernote/server/app.py

@@ -6,9 +6,9 @@ from typing import Any, Awaitable, Callable
 
 from aiohttp import web
 
-from supernote.server.services.user import JWT_ALGORITHM, JWT_SECRET
+from supernote.server.services.user import JWT_ALGORITHM
 
-from . import config
+from .config import ServerConfig
 from .models.base import create_error_response
 from .routes import auth, file, system
 from .services.file import FileService
@@ -56,8 +56,11 @@ async def trace_middleware(
         "body": body_str,
     }
 
+    # Get config from app
+    server_config: ServerConfig = request.app["config"]
+
     try:
-        with open(config.TRACE_LOG_FILE, "a") as f:
+        with open(server_config.trace_log_file, "a") as f:
             f.write(json.dumps(log_entry) + "\n")
             f.flush()
     except Exception as e:
@@ -92,8 +95,12 @@ async def jwt_auth_middleware(
 
     import jwt
 
+    server_config: ServerConfig = request.app["config"]
+
     try:
-        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
+        payload = jwt.decode(
+            token, server_config.auth.secret_key, algorithms=[JWT_ALGORITHM]
+        )
     except jwt.InvalidTokenError:
         return web.json_response(
             create_error_response("Invalid token").to_dict(), status=401
@@ -102,15 +109,19 @@ async def jwt_auth_middleware(
     return await handler(request)
 
 
-def create_app() -> web.Application:
+def create_app(config: ServerConfig | None = None) -> web.Application:
+    if config is None:
+        config = ServerConfig.load()
+
     app = web.Application(middlewares=[trace_middleware, jwt_auth_middleware])
+    app["config"] = config
 
     # Initialize services
-    storage_root = Path(config.STORAGE_DIR)
+    storage_root = Path(config.storage_dir)
     temp_root = storage_root / "temp"
     storage_service = StorageService(storage_root, temp_root)
     app["storage_service"] = storage_service
-    app["user_service"] = UserService(config.USER_CONFIG_FILE)
+    app["user_service"] = UserService(config.auth)
     app["file_service"] = FileService(storage_service)
 
     # Register routes
@@ -125,5 +136,7 @@ def create_app() -> web.Application:
 
 def run(args: Any) -> None:
     logging.basicConfig(level=logging.DEBUG)
-    app = create_app()
-    web.run_app(app, host=config.HOST, port=config.PORT)
+    config_dir = getattr(args, "config_dir", None)
+    config = ServerConfig.load(config_dir)
+    app = create_app(config)
+    web.run_app(app, host=config.host, port=config.port)

supernote-0.5.0/supernote/server/config.py

@@ -0,0 +1,159 @@
+import logging
+import os
+import secrets
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+from mashumaro.mixins.dict import DataClassDictMixin
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AuthConfig(DataClassDictMixin):
+    secret_key: str = ""
+    expiration_hours: int = 24
+    users_file: str = "users.yaml"
+
+
+@dataclass
+class UserEntry(DataClassDictMixin):
+    username: str
+    password_md5: str
+    is_active: bool = True
+    devices: list[str] = field(default_factory=list)
+    profile: dict[str, Any] = field(default_factory=dict)
+    mobile: str | None = None
+    email: str | None = None
+    avatar: str | None = None
+    signature: str | None = None
+
+
+@dataclass
+class UsersConfig(DataClassDictMixin):
+    users: list[UserEntry] = field(default_factory=list)
+
+    @classmethod
+    def load(cls, path: str | Path) -> "UsersConfig":
+        path = Path(path)
+        if not path.exists():
+            return cls()
+        try:
+            with open(path, "r") as f:
+                data = yaml.safe_load(f) or {}
+            return cls.from_dict(data)
+        except Exception as e:
+            logger.warning(f"Failed to load users file {path}: {e}")
+            return cls()
+
+    def save(self, path: str | Path) -> None:
+        path = Path(path)
+        if not path.parent.exists():
+            path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            yaml.safe_dump(self.to_dict(), f, default_flow_style=False)
+
+
+@dataclass
+class ServerConfig(DataClassDictMixin):
+    host: str = "0.0.0.0"
+    port: int = 8080
+    trace_log_file: str = "data/server_trace.log"
+    storage_dir: str = "storage"
+    auth: AuthConfig = field(default_factory=AuthConfig)
+
+    @classmethod
+    def load(cls, config_dir: str | Path | None = None) -> "ServerConfig":
+        """Load configuration from directory."""
+        # 1. Determine config directory
+        if config_dir is None:
+            config_dir = os.getenv("SUPERNOTE_CONFIG_DIR", "config")
+
+        config_dir_path = Path(config_dir)
+        config_file = config_dir_path / "config.yaml"
+
+        # 2. Load from YAML if exists
+        file_data: dict[str, Any] = {}
+        if file_exists := config_file.exists():
+            try:
+                with open(config_file, "r") as f:
+                    file_data = yaml.safe_load(f) or {}
+            except Exception as e:
+                logger.warning(f"Failed to load config file {config_file}: {e}")
+
+        # 3. Create config object using mashumaro
+        try:
+            config = cls.from_dict(file_data)
+        except Exception as e:
+            logger.warning(
+                f"Failed to parse config file {config_file}, using defaults: {e}"
+            )
+            config = cls()
+
+        # Resolve users_file relative to config_dir if not absolute
+        users_path = Path(config.auth.users_file)
+        if not users_path.is_absolute():
+            config.auth.users_file = str(config_dir_path / users_path)
+
+        # 4. Generate secret if missing AND not provided by env var
+        env_secret = os.getenv("SUPERNOTE_JWT_SECRET")
+        secret_generated = False
+
+        if not config.auth.secret_key and not env_secret:
+            logger.warning("No JWT secret key configured. Generating a new random key.")
+            config.auth.secret_key = secrets.token_hex(32)
+            secret_generated = True
+
+        # 5. Save config if it was missing or if we generated a secret
+        if not file_exists or secret_generated:
+            try:
+                # Ensure directory exists
+                if not config_file.parent.exists():
+                    config_file.parent.mkdir(parents=True, exist_ok=True)
+
+                # Prepare config for saving (restore relative paths if possible)
+                config_to_save = cls.from_dict(config.to_dict())
+                try:
+                    users_path_abs = Path(config.auth.users_file)
+                    if users_path_abs.is_absolute() and users_path_abs.is_relative_to(
+                        config_dir_path
+                    ):
+                        config_to_save.auth.users_file = str(
+                            users_path_abs.relative_to(config_dir_path)
+                        )
+                except ValueError:
+                    pass
+
+                with open(config_file, "w") as f:
+                    yaml.safe_dump(
+                        config_to_save.to_dict(), f, default_flow_style=False
+                    )
+
+                if secret_generated:
+                    logger.info(
+                        f"Saved new configuration with generated secret to {config_file}"
+                    )
+                else:
+                    logger.info(f"Created default configuration file at {config_file}")
+            except Exception as e:
+                logger.warning(f"Failed to save configuration to {config_file}: {e}")
+
+        # 6. Apply env var override (runtime only, not saved)
+        if env_secret:
+            config.auth.secret_key = env_secret
+
+        if os.getenv("SUPERNOTE_HOST"):
+            config.host = os.getenv("SUPERNOTE_HOST", config.host)
+
+        if os.getenv("SUPERNOTE_PORT"):
+            try:
+                config.port = int(os.getenv("SUPERNOTE_PORT", str(config.port)))
+            except ValueError:
+                pass
+
+        if os.getenv("SUPERNOTE_STORAGE_DIR"):
+            config.storage_dir = os.getenv("SUPERNOTE_STORAGE_DIR", config.storage_dir)
+
+        return config

{supernote-0.4.0 → supernote-0.5.0}/supernote/server/services/user.py

@@ -1,73 +1,59 @@
 import hashlib
 import logging
-import os
 import secrets
 import time
 from typing import Optional
 
 import jwt
-import yaml
 
+from ..config import AuthConfig, UserEntry, UsersConfig
 from ..models.auth import LoginResult, UserVO
 
 logger = logging.getLogger(__name__)
 
-# TODO: This should be generated on first startup and stored somewhere secure
-JWT_SECRET = os.environ.get("SUPERNOTE_JWT_SECRET", "supernote-secret-key")
 JWT_ALGORITHM = "HS256"
-JWT_EXPIRATION_HOURS = int(os.environ.get("SUPERNOTE_JWT_EXPIRATION_HOURS", "24"))
-
-
-def _load_users(users_file: str) -> list[dict]:
-    if not os.path.exists(users_file):
-        return []
-    with open(users_file, "r") as f:
-        data = yaml.safe_load(f) or {"users": []}
-        return data.get("users") or []
-
-
-def _save_users(users_file: str, users: list[dict]) -> None:
-    with open(users_file, "w") as f:
-        yaml.safe_dump({"users": users}, f, default_flow_style=False)
 
 
 class UserService:
-    def __init__(self, users_file: str):
-        self._users_file = users_file
-        self._users = _load_users(users_file)
+    def __init__(self, config: AuthConfig):
+        self._config = config
+        self._users_config = UsersConfig.load(config.users_file)
         self._random_codes: dict[
             str, tuple[str, str]
         ] = {}  # account -> (code, timestamp)
 
-    def list_users(self) -> list[dict]:
+    @property
+    def _users(self) -> list[UserEntry]:
+        return self._users_config.users
+
+    def list_users(self) -> list[UserEntry]:
         return list(self._users)
 
     def add_user(self, username: str, password: str) -> bool:
-        if any(u["username"] == username for u in self._users):
+        if any(u.username == username for u in self._users):
             return False
         password_md5 = hashlib.md5(password.encode()).hexdigest()
-        self._users.append(
-            {
-                "username": username,
-                "password_md5": password_md5,
-                "is_active": True,
-                "devices": [],  # List of bound equipment numbers
-                "profile": {},  # User profile data
-            }
+        new_user = UserEntry(
+            username=username,
+            password_md5=password_md5,
+            is_active=True,
+            devices=[],
+            profile={},
         )
-        _save_users(self._users_file, self._users)
+        self._users.append(new_user)
+        self._users_config.save(self._config.users_file)
         return True
 
     def deactivate_user(self, username: str) -> bool:
         for user in self._users:
-            if user["username"] == username:
-                user["is_active"] = False
-                _save_users(self._users_file, self._users)
+            if user.username == username:
+                user.is_active = False
+                self._users_config.save(self._config.users_file)
                 return True
         return False
 
     def check_user_exists(self, account: str) -> bool:
-        return any(u["username"] == account for u in self._users)
+        return any(u.username == account for u in self._users)
 
     def generate_random_code(self, account: str) -> tuple[str, str]:
         """Generate a random code for login challenge."""
@@ -77,30 +63,31 @@ class UserService:
         self._random_codes[account] = (random_code, timestamp)
         return random_code, timestamp
 
-    def _get_user(self, account: str) -> dict | None:
+    def _get_user(self, account: str) -> UserEntry | None:
         for user in self._users:
-            if user["username"] == account:
+            if user.username == account:
                 return user
         return None
 
     def verify_password(self, account: str, password: str) -> bool:
         user = self._get_user(account)
-        if not user or not user.get("is_active", True):
+        if not user or not user.is_active:
             logger.info("User not found or inactive: %s", account)
             return False
-        if (password_md5 := user.get("password_md5")) is None:
+        if not user.password_md5:
             logger.info("MD5 password hash not found for user: %s", account)
             return False
         # Compute md5(password) and compare
         password_bytes = password.encode()
         hash_hex = hashlib.md5(password_bytes).hexdigest()
-        return bool(hash_hex == password_md5)
+        return bool(hash_hex == user.password_md5)
 
     def verify_login_hash(self, account: str, client_hash: str, timestamp: str) -> bool:
         user = self._get_user(account)
-        if not user or not user.get("is_active", True):
+        if not user or not user.is_active:
             logger.info("User not found or inactive: %s", account)
             return False
+
         code_tuple = self._random_codes.get(account)
         if not code_tuple or code_tuple[1] != timestamp:
             logger.warning(
@@ -108,12 +95,15 @@ class UserService:
             )
             return False
         random_code = code_tuple[0]
-        if (password_md5 := user.get("password_md5")) is None:
+
+        if not user.password_md5:
             logger.info("MD5 password hash not found for user: %s", account)
             return False
-        # Compute expected hash: sha256(password_md5 + random_code + timestamp)
-        concat = password_md5 + random_code
+
+        # Compute expected hash: sha256(password_md5 + random_code)
+        concat = user.password_md5 + random_code
         expected_hash = hashlib.sha256(concat.encode()).hexdigest()
+
         if expected_hash == client_hash:
             return True
         logger.info("Login hash mismatch for user: %s", account)
@@ -138,7 +128,7 @@ class UserService:
           LoginResult if login is successful, None otherwise.
         """
         user = self._get_user(account)
-        if not user or not user.get("is_active", True):
+        if not user or not user.is_active:
             # TODO: Raise exceptions so we can return a useful error message
             # to the web APIs.
             logger.warning("Login failed: user not found or inactive: %s", account)
@@ -155,7 +145,7 @@ class UserService:
             return None
 
         # Check binding status
-        bound_devices = user.get("devices", [])
+        bound_devices = user.devices
         is_bind = "Y" if bound_devices else "N"
         is_bind_equipment = "N"
         if equipment_no and equipment_no in bound_devices:
@@ -165,9 +155,9 @@ class UserService:
             "sub": account,
             "equipment_no": equipment_no or "",
             "iat": int(time.time()),
-            "exp": int(time.time()) + (JWT_EXPIRATION_HOURS * 3600),
+            "exp": int(time.time()) + (self._config.expiration_hours * 3600),
         }
-        token = jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
+        token = jwt.encode(payload, self._config.secret_key, algorithm=JWT_ALGORITHM)
 
         return LoginResult(
             token=token,
@@ -182,17 +172,17 @@ class UserService:
             return None
 
         # Default profile values
-        username = user["username"]
-        profile = user.get("profile", {})
+        username = user.username
+        profile = user.profile
 
         return UserVO(
             user_name=profile.get("user_name", username),
-            email=profile.get("email", username),
-            phone=profile.get("phone", ""),
+            email=user.email or profile.get("email", username),
+            phone=user.mobile or profile.get("phone", ""),
             country_code=profile.get("country_code", "1"),
             total_capacity=profile.get("total_capacity", "25485312"),
             file_server=profile.get("file_server", "0"),
-            avatars_url=profile.get("avatars_url", ""),
+            avatars_url=user.avatar or profile.get("avatars_url", ""),
             birthday=profile.get("birthday", ""),
             sex=profile.get("sex", ""),
         )
@@ -205,11 +195,9 @@ class UserService:
             logger.warning("User not found for binding: %s", account)
             return False
 
-        devices = user.get("devices", [])
-        if equipment_no not in devices:
-            devices.append(equipment_no)
-            user["devices"] = devices
-            _save_users(self._users_file, self._users)
+        if equipment_no not in user.devices:
+            user.devices.append(equipment_no)
+            self._users_config.save(self._config.users_file)
 
         return True
 
@@ -218,13 +206,11 @@ class UserService:
         logger.info("Unlinking equipment %s", equipment_no)
         found = False
         for user in self._users:
-            devices = user.get("devices", [])
-            if equipment_no in devices:
-                devices.remove(equipment_no)
-                user["devices"] = devices
+            if equipment_no in user.devices:
+                user.devices.remove(equipment_no)
                 found = True
 
         if found:
-            _save_users(self._users_file, self._users)
+            self._users_config.save(self._config.users_file)
 
         return True

{supernote-0.4.0 → supernote-0.5.0}/supernote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.4.0
+Version: 0.5.0
 Summary: All-in-one toolkit for Supernote devices: parse notebooks, self-host services, access services
 Author-email: jya <jya@wizmy.net>, Allen Porter <allen.porter@gmail.com>
 License-Expression: Apache-2.0

supernote-0.4.0/supernote/server/config.py

@@ -1,16 +0,0 @@
-import os
-
-# Default port for Supernote Private Cloud
-PORT = int(os.getenv("SUPERNOTE_PORT", "8080"))
-HOST = os.getenv("SUPERNOTE_HOST", "0.0.0.0")
-TRACE_LOG_FILE = os.getenv("SUPERNOTE_TRACE_LOG", "data/server_trace.log")
-STORAGE_DIR = os.getenv("SUPERNOTE_STORAGE_DIR", "storage")
-USER_CONFIG_FILE = os.getenv("SUPERNOTE_USER_CONFIG_FILE", "config/users.yaml")
-
-
-class Config:
-    PORT = PORT
-    HOST = HOST
-    TRACE_LOG_FILE = TRACE_LOG_FILE
-    STORAGE_DIR = STORAGE_DIR
-    USER_CONFIG_FILE = USER_CONFIG_FILE