supernote 0.5.0__tar.gz → 0.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.5.0
+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.5.0 → 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.5.0 → supernote-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0"]
 
 [project]
 name = "supernote"
-version = "0.5.0"
+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.5.0 → supernote-0.6.0}/supernote/server/app.py

@@ -123,6 +123,7 @@ def create_app(config: ServerConfig | None = None) -> web.Application:
     app["storage_service"] = storage_service
     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)

{supernote-0.5.0 → supernote-0.6.0}/supernote/server/config.py

@@ -92,9 +92,9 @@ class ServerConfig(DataClassDictMixin):
             )
             config = cls()
 
-        # Resolve users_file relative to config_dir if not absolute
+        # 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():
+        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

{supernote-0.5.0 → 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 = "/"

{supernote-0.5.0 → supernote-0.6.0}/supernote/server/routes/file.py

@@ -1,10 +1,11 @@
 import asyncio
 import logging
+import time
 import urllib.parse
 
-from aiohttp import web
+from aiohttp import BodyPartReader, web
 
-from ..models.base import BaseResponse
+from ..models.base import BaseResponse, create_error_response
 from ..models.file import (
     AllocationVO,
     CapacityResponse,
@@ -23,6 +24,7 @@ from ..models.file import (
     ListFolderResponse,
     RecycleFileListRequest,
     RecycleFileRequest,
+    SyncEndRequest,
     SyncStartRequest,
     SyncStartResponse,
     UploadApplyRequest,
@@ -35,16 +37,43 @@ logger = logging.getLogger(__name__)
 routes = web.RouteTableDef()
 
 
+SYNC_LOCK_TIMEOUT = 300  # 5 minutes
+
+
 @routes.post("/api/file/2/files/synchronous/start")
 async def handle_sync_start(request: web.Request) -> web.Response:
     # Endpoint: POST /api/file/2/files/synchronous/start
     # Purpose: Start a file synchronization session.
     # Response: SynchronousStartLocalVO
     req_data = SyncStartRequest.from_dict(await request.json())
+    user_email = request["user"]
+    sync_locks = request.app["sync_locks"]
+    storage_service: StorageService = request.app["storage_service"]
+
+    loop = asyncio.get_running_loop()
+    is_empty = await loop.run_in_executor(None, storage_service.is_empty, user_email)
+
+    now = time.time()
+    if user_email in sync_locks:
+        owner_eq, expiry = sync_locks[user_email]
+        if now < expiry and owner_eq != req_data.equipment_no:
+            logger.info(
+                f"Sync conflict: user {user_email} already syncing from {owner_eq}"
+            )
+            return web.json_response(
+                create_error_response(
+                    error_msg="Another device is synchronizing",
+                    error_code="E0078",
+                ).to_dict(),
+                status=409,
+            )
+
+    sync_locks[user_email] = (req_data.equipment_no, now + SYNC_LOCK_TIMEOUT)
+
     return web.json_response(
         SyncStartResponse(
             equipment_no=req_data.equipment_no,
-            syn_type=True,  # True for normal sync, False for full re-upload
+            syn_type=not is_empty,
         ).to_dict()
     )
 
@@ -53,8 +82,17 @@ async def handle_sync_start(request: web.Request) -> web.Response:
 async def handle_sync_end(request: web.Request) -> web.Response:
     # Endpoint: POST /api/file/2/files/synchronous/end
     # Purpose: End a file synchronization session.
-    SyncStartRequest.from_dict(await request.json())
-    return web.json_response(BaseResponse().to_dict())
+    req_data = SyncEndRequest.from_dict(await request.json())
+    user_email = request["user"]
+
+    # Release lock
+    sync_locks = request.app["sync_locks"]
+    if user_email in sync_locks:
+        owner_eq, _ = sync_locks[user_email]
+        if owner_eq == req_data.equipment_no:
+            del sync_locks[user_email]
+
+    return web.json_response(BaseResponse(success=True).to_dict())
 
 
 @routes.post("/api/file/2/files/list_folder")
@@ -66,10 +104,13 @@ async def handle_list_folder(request: web.Request) -> web.Response:
 
     req_data = ListFolderRequest.from_dict(await request.json())
     path_str = req_data.path
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     loop = asyncio.get_running_loop()
-    entries = await loop.run_in_executor(None, file_service.list_folder, path_str)
+    entries = await loop.run_in_executor(
+        None, file_service.list_folder, user_email, path_str
+    )
 
     return web.json_response(
         ListFolderResponse(
@@ -86,10 +127,13 @@ async def handle_capacity_query(request: web.Request) -> web.Response:
 
     req_data = await request.json()
     equipment_no = req_data.get("equipmentNo", "")
-    
+    user_email = request["user"]
+
     storage_service: StorageService = request.app["storage_service"]
     loop = asyncio.get_running_loop()
-    used = await loop.run_in_executor(None, storage_service.get_storage_usage)
+    used = await loop.run_in_executor(
+        None, storage_service.get_storage_usage, user_email
+    )
 
     return web.json_response(
         CapacityResponse(
@@ -111,10 +155,13 @@ async def handle_query_by_path(request: web.Request) -> web.Response:
 
     req_data = FileQueryRequest.from_dict(await request.json())
     path_str = req_data.path
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     loop = asyncio.get_running_loop()
-    entries_vo = await loop.run_in_executor(None, file_service.get_file_info, path_str)
+    entries_vo = await loop.run_in_executor(
+        None, file_service.get_file_info, user_email, path_str
+    )
 
     return web.json_response(
         FileQueryResponse(
@@ -131,10 +178,13 @@ async def handle_query_v3(request: web.Request) -> web.Response:
 
     req_data = FileQueryByIdRequest.from_dict(await request.json())
     file_id = req_data.id
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     loop = asyncio.get_running_loop()
-    entries_vo = await loop.run_in_executor(None, file_service.get_file_info, file_id)
+    entries_vo = await loop.run_in_executor(
+        None, file_service.get_file_info, user_email, file_id
+    )
 
     return web.json_response(
         FileQueryResponse(
@@ -152,10 +202,11 @@ async def handle_upload_apply(request: web.Request) -> web.Response:
 
     req_data = UploadApplyRequest.from_dict(await request.json())
     file_name = req_data.file_name
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     response = file_service.apply_upload(
-        file_name, req_data.equipment_no or "", request.host
+        user_email, file_name, req_data.equipment_no or "", request.host
     )
 
     return web.json_response(response.to_dict())
@@ -168,32 +219,26 @@ async def handle_upload_data(request: web.Request) -> web.Response:
     # Purpose: Receive the actual file content.
 
     filename = request.match_info["filename"]
+    user_email = request["user"]
     storage_service: StorageService = request.app["storage_service"]
 
     # The device sends multipart/form-data
-    # Note: trace_middleware might have consumed the body already if we are not careful.
-    # But trace_middleware uses request.read() which caches the body, so it should be fine?
-    # Actually, request.read() reads the whole body into memory.
-    # request.multipart() expects to read from the stream.
-    # If the body is already read, we might need to handle it differently.
-
     if request._read_bytes:
         # Body already read by middleware
-        # We need to reconstruct a multipart reader or just parse it manually if possible.
-        # However, aiohttp's multipart reader expects a stream.
-        # Since we are in a "lite" server, maybe we can just skip the middleware for this route
-        # or make the middleware smarter.
-        # For now, let's try to use the standard multipart reader which might fail if stream is consumed.
         pass
 
     reader = await request.multipart()
 
     # Read the first part (which should be the file)
     field = await reader.next()
-    if field.name == "file":  # type: ignore[union-attr]
+    if isinstance(field, BodyPartReader) and field.name == "file":
         # Write to temp file using non-blocking I/O
-        total_bytes = await storage_service.save_temp_file(filename, field.read_chunk)  # type: ignore[union-attr]
-        logger.info(f"Received upload for {filename}: {total_bytes} bytes")
+        total_bytes = await storage_service.save_temp_file(
+            user_email, filename, field.read_chunk
+        )
+        logger.info(
+            f"Received upload for {filename} (user: {user_email}): {total_bytes} bytes"
+        )
 
     return web.Response(status=200)
 
@@ -205,6 +250,7 @@ async def handle_upload_finish(request: web.Request) -> web.Response:
     # Response: FileUploadFinishLocalVO
 
     req_data = UploadFinishRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     loop = asyncio.get_running_loop()
@@ -213,6 +259,7 @@ async def handle_upload_finish(request: web.Request) -> web.Response:
         response = await loop.run_in_executor(
             None,
             file_service.finish_upload,
+            user_email,
             req_data.file_name,
             req_data.path,
             req_data.content_hash,
@@ -234,10 +281,11 @@ async def handle_download_apply(request: web.Request) -> web.Response:
 
     req_data = DownloadApplyRequest.from_dict(await request.json())
     file_id = req_data.id  # This is the relative path now
+    user_email = request["user"]
     storage_service: StorageService = request.app["storage_service"]
 
     # Verify file exists
-    target_path = storage_service.resolve_path(file_id)
+    target_path = storage_service.resolve_path(user_email, file_id)
     if not target_path.exists():
         return web.json_response(
             BaseResponse(success=False, error_msg="File not found").to_dict(),
@@ -260,11 +308,12 @@ async def handle_download_data(request: web.Request) -> web.StreamResponse:
     if not path_str:
         return web.Response(status=400, text="Missing path")
 
+    user_email = request["user"]
     storage_service: StorageService = request.app["storage_service"]
-    target_path = storage_service.resolve_path(path_str)
+    target_path = storage_service.resolve_path(user_email, path_str)
 
     # Security check: prevent directory traversal
-    if not storage_service.is_safe_path(target_path):
+    if not storage_service.is_safe_path(user_email, target_path):
         return web.Response(status=403, text="Access denied")
 
     if not target_path.exists():
@@ -279,9 +328,11 @@ async def handle_create_folder(request: web.Request) -> web.Response:
     # Purpose: Create a new folder.
 
     req_data = CreateDirectoryRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     response = file_service.create_directory(
+        user_email,
         req_data.path,
         req_data.equipment_no,
     )
@@ -295,10 +346,12 @@ async def handle_delete_folder(request: web.Request) -> web.Response:
     # Purpose: Delete a file or folder.
 
     req_data = DeleteRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     # Request has 'id' (int) now
     response = file_service.delete_item(
+        user_email,
         req_data.id,
         req_data.equipment_no,
     )
@@ -312,9 +365,11 @@ async def handle_move_file(request: web.Request) -> web.Response:
     # Purpose: Move a file or folder.
 
     req_data = FileMoveRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     response = file_service.move_item(
+        user_email,
         req_data.id,
         req_data.to_path,
         req_data.autorename,
@@ -330,9 +385,11 @@ async def handle_copy_file(request: web.Request) -> web.Response:
     # Purpose: Copy a file or folder.
 
     req_data = FileCopyRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     response = file_service.copy_item(
+        user_email,
         req_data.id,
         req_data.to_path,
         req_data.autorename,
@@ -348,10 +405,15 @@ async def handle_recycle_list(request: web.Request) -> web.Response:
     # Purpose: List files in recycle bin.
 
     req_data = RecycleFileListRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
     response = file_service.list_recycle(
-        req_data.order, req_data.sequence, req_data.page_no, req_data.page_size
+        user_email,
+        req_data.order,
+        req_data.sequence,
+        req_data.page_no,
+        req_data.page_size,
     )
 
     return web.json_response(response.to_dict())
@@ -363,9 +425,10 @@ async def handle_recycle_delete(request: web.Request) -> web.Response:
     # Purpose: Permanently delete items from recycle bin.
 
     req_data = RecycleFileRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
-    response = file_service.delete_from_recycle(req_data.id_list)
+    response = file_service.delete_from_recycle(user_email, req_data.id_list)
 
     return web.json_response(response.to_dict())
 
@@ -376,9 +439,10 @@ async def handle_recycle_revert(request: web.Request) -> web.Response:
     # Purpose: Restore items from recycle bin.
 
     req_data = RecycleFileRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
-    response = file_service.revert_from_recycle(req_data.id_list)
+    response = file_service.revert_from_recycle(user_email, req_data.id_list)
 
     return web.json_response(response.to_dict())
 
@@ -388,9 +452,10 @@ async def handle_recycle_clear(request: web.Request) -> web.Response:
     # Endpoint: POST /api/file/recycle/clear
     # Purpose: Empty the recycle bin.
 
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
-    response = file_service.clear_recycle()
+    response = file_service.clear_recycle(user_email)
 
     return web.json_response(response.to_dict())
 
@@ -401,9 +466,10 @@ async def handle_file_search(request: web.Request) -> web.Response:
     # Purpose: Search for files by keyword.
 
     req_data = FileSearchRequest.from_dict(await request.json())
+    user_email = request["user"]
     file_service: FileService = request.app["file_service"]
 
-    results = file_service.search_files(req_data.keyword)
+    results = file_service.search_files(user_email, req_data.keyword)
 
     response = FileSearchResponse(entries=results)