supernote 0.4.1__tar.gz → 0.6.0__tar.gz

{supernote-0.4.1 → supernote-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.4.1
+Version: 0.6.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
@@ -82,8 +82,11 @@ limitation. All credit goes to the original authors of [supernote-tool](https://
 ### Run Private Server
 
 ```bash
-# Configure users (you will be prompted for a password)
-supernote-server user add alice
+# Generate configuration
+supernote-server config init > config.yaml
+
+# Generate users (outputs YAML, append to users.yaml)
+supernote-server user add alice >> users.yaml
 
 # Start server
 supernote-server serve
@@ -95,9 +98,10 @@ supernote-server serve
 # Build image
 docker build -t supernote-server .
 
-# Create user
+# Generate initial configuration
 mkdir config
-docker run --rm -it -v $(pwd)/config:/config supernote-server supernote-server user add alice
+docker run --rm supernote-server supernote-server config init > config/config.yaml
+docker run --rm -it supernote-server supernote-server user add alice >> config/users.yaml
 
 # Run server
 docker run -d -p 8080:8080 \

{supernote-0.4.1 → supernote-0.6.0}/README.md

@@ -52,8 +52,11 @@ limitation. All credit goes to the original authors of [supernote-tool](https://
 ### Run Private Server
 
 ```bash
-# Configure users (you will be prompted for a password)
-supernote-server user add alice
+# Generate configuration
+supernote-server config init > config.yaml
+
+# Generate users (outputs YAML, append to users.yaml)
+supernote-server user add alice >> users.yaml
 
 # Start server
 supernote-server serve
@@ -65,9 +68,10 @@ supernote-server serve
 # Build image
 docker build -t supernote-server .
 
-# Create user
+# Generate initial configuration
 mkdir config
-docker run --rm -it -v $(pwd)/config:/config supernote-server supernote-server user add alice
+docker run --rm supernote-server supernote-server config init > config/config.yaml
+docker run --rm -it supernote-server supernote-server user add alice >> config/users.yaml
 
 # Run server
 docker run -d -p 8080:8080 \

{supernote-0.4.1 → supernote-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0"]
 
 [project]
 name = "supernote"
-version = "0.4.1"
+version = "0.6.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.6.0/supernote/cli/server.py

@@ -0,0 +1,137 @@
+"""Server CLI commands."""
+
+import argparse
+import getpass
+import secrets
+
+import yaml
+
+from supernote.server import app as server_app
+from supernote.server.config import AuthConfig, ServerConfig, UsersConfig
+from supernote.server.services.user import UserService
+
+
+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(config_dir: str | None):
+    config = get_auth_config(config_dir)
+    service = UserService(config)
+    for user in service.list_users():
+        status = "active" if user.is_active else "inactive"
+        print(f"{user.username} ({status})")
+
+
+def add_user(username: str, password: str | None = None):
+    if password is None:
+        password = getpass.getpass(f"Password for {username}: ")
+
+    # Generate the YAML snippet for a single user
+    user_entry = UserService.create_user_entry(username, password)
+    users_config = UsersConfig(users=[user_entry])
+
+    # Print YAML to stdout
+    print("# Generated Supernote User Entry")
+    print("# Append this to your users.yaml file.")
+    print(yaml.safe_dump(users_config.to_dict(), default_flow_style=False))
+
+
+def config_init():
+    """Output a default config.yaml with a generated secret."""
+    secret = secrets.token_hex(32)
+    config = ServerConfig()
+    config.auth.secret_key = secret
+
+    print("# Generated Supernote Server Configuration")
+    print("# Save this as config.yaml.")
+    print(yaml.safe_dump(config.to_dict(), default_flow_style=False))
+
+
+def generate_secret():
+    """Output a 32-byte random hex secret."""
+    print(secrets.token_hex(32))
+
+
+def add_parser(subparsers):
+    # Common parent parser for server-related commands that need config access
+    base_parser = argparse.ArgumentParser(add_help=False)
+    base_parser.add_argument(
+        "--config-dir",
+        type=str,
+        default=None,
+        help="Path to configuration directory (default: config/)",
+    )
+
+    # 'serve' subcommand
+    parser_serve = subparsers.add_parser(
+        "serve",
+        parents=[base_parser],
+        help="Start the Supernote Private Cloud server",
+    )
+    parser_serve.set_defaults(func=server_app.run)
+
+    # User management
+    parser_user = subparsers.add_parser("user", help="User management commands")
+    user_subparsers = parser_user.add_subparsers(dest="user_command")
+
+    # user list
+    parser_user_list = user_subparsers.add_parser(
+        "list",
+        parents=[base_parser],
+        help="List all users in the current config file",
+    )
+    parser_user_list.set_defaults(
+        func=lambda args: list_users(getattr(args, "config_dir", None))
+    )
+
+    # user add
+    parser_user_add = user_subparsers.add_parser(
+        "add",
+        parents=[base_parser],
+        help="Generate a user configuration snippet",
+    )
+    parser_user_add.add_argument("username", type=str, help="Username for the new user")
+    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.username, args.password)
+    )
+
+    # config group
+    parser_config = subparsers.add_parser("config", help="Configuration utilities")
+    config_subparsers = parser_config.add_subparsers(dest="config_command")
+
+    # config init
+    parser_config_init = config_subparsers.add_parser(
+        "init",
+        parents=[base_parser],
+        help="Generate a default config.yaml",
+    )
+    parser_config_init.set_defaults(func=lambda _: config_init())
+
+    # config secret
+    parser_config_secret = config_subparsers.add_parser(
+        "generate-secret",
+        parents=[base_parser],
+        help="Generate a secure random secret",
+    )
+    parser_config_secret.set_defaults(func=lambda _: generate_secret())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Supernote Server CLI")
+    subparsers = parser.add_subparsers(dest="command")
+    add_parser(subparsers)
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

{supernote-0.4.1 → supernote-0.6.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.1 → supernote-0.6.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,16 +109,21 @@ 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)
+    app["sync_locks"] = {}  # user -> (equipment_no, expiry_time)
 
     # Register routes
     app.add_routes(system.routes)
@@ -125,5 +137,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.6.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 it's just a filename (not already a path)
+        users_path = Path(config.auth.users_file)
+        if not users_path.is_absolute() and len(users_path.parts) == 1:
+            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.1 → supernote-0.6.0}/supernote/server/models/file.py

@@ -25,6 +25,17 @@ class SyncStartRequest(DataClassJSONMixin):
         code_generation_options = [TO_DICT_ADD_OMIT_NONE_FLAG]  # type: ignore[list-item]
 
 
+@dataclass
+class SyncEndRequest(DataClassJSONMixin):
+    equipment_no: str = field(metadata=field_options(alias="equipmentNo"))
+    flag: str | None = None  # "true" or "false"
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+        omit_none = True
+        code_generation_options = [TO_DICT_ADD_OMIT_NONE_FLAG]  # type: ignore[list-item]
+
+
 @dataclass
 class ListFolderRequest(DataClassJSONMixin):
     path: str = "/"