MetaList 0.3.11__tar.gz → 0.3.12__tar.gz

{metalist-0.3.11 → metalist-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.3.11
+Version: 0.3.12
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -10,11 +10,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: argon2-cffi==25.1.0
 Requires-Dist: cryptography==50.0.0
 Requires-Dist: fastapi==0.141.1
+Requires-Dist: httpcore==1.0.9
 Requires-Dist: httpx==0.28.1
 Requires-Dist: latex2mathml==3.81.0
 Requires-Dist: loguru==0.7.3
 Requires-Dist: Mako==1.3.12
 Requires-Dist: mutagen==1.48.1
+Requires-Dist: nh3==0.3.6
+Requires-Dist: pillow==12.3.0
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-multipart==0.0.32
 Requires-Dist: starlette==1.3.1
@@ -22,6 +25,7 @@ Requires-Dist: tqdm==4.70.0
 Requires-Dist: tree-sitter==0.25.2
 Requires-Dist: tree-sitter-javascript==0.25.0
 Requires-Dist: uvicorn==0.52.0
+Requires-Dist: zxcvbn==4.5.0
 Provides-Extra: dev
 Requires-Dist: hypothesis==6.164.0; extra == "dev"
 Requires-Dist: pytest==9.1.1; extra == "dev"
@@ -99,8 +103,22 @@ metalist
 ```
 For source-checkout compatibility, `python main.py` performs the same orchestration. Use `metalist work`, `python main.py --namespace work`, or `python main.py work` when you want one foreground namespace process.
 
-`metalist` and explicit single-namespace source runs bind HTTP on `0.0.0.0:8000` by default, matching the old MetaList LAN-friendly behavior.
-On first startup, MetaList also auto-generates a self-signed TLS pair at `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`, then enables HTTPS on `0.0.0.0:8443`. If you already have real PEM files, point `METALIST_TLS_CERT` and `METALIST_TLS_KEY` at them instead. Set `METALIST_AUTO_GENERATE_TLS=0` only if you explicitly want HTTP-only startup.
+Shell execution is disabled by default. To enable `@shell` for every namespace
+started by the top-level orchestrator, use either:
+
+```bash
+metalist --enable-shell
+python main.py --enable-shell
+```
+
+This flag is propagated to every namespace child process. The top-level process
+prints a conspicuous shell-enabled banner before its namespace launch results.
+Use `python main.py work --enable-shell` for one foreground namespace. Shell
+routes remain restricted to loopback clients using a loopback request host,
+even when the rest of MetaList is intentionally exposed to a LAN.
+
+`metalist` and explicit single-namespace source runs bind to loopback at `127.0.0.1:8000` by default. This keeps a normal laptop launch off LAN and public interfaces unless remote access is explicitly configured.
+On first startup, MetaList also auto-generates a self-signed TLS pair at `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`, then enables HTTPS on the same bind host at port `8443`. If you already have real PEM files, point `METALIST_TLS_CERT` and `METALIST_TLS_KEY` at them instead. Set `METALIST_AUTO_GENERATE_TLS=0` only if you explicitly want HTTP-only startup.
 
 Database selection:
 - No explicit namespace on a single-namespace launch: `~/MetaList/namespaces/default/default.metalist.db`
@@ -116,20 +134,36 @@ Useful env flags:
 - `CRASH_SERVER_ON_FAIL=1` (default): fail-fast on validation errors
 - `API_PREFIX=/api2`: override API prefix (client assumes `/api2` by default)
 - `METALIST_NAMESPACE=work`: select `~/MetaList/namespaces/work/work.metalist.db`
-- `METALIST_HOST=0.0.0.0` (default): bind the main app to a different interface such as `127.0.0.1`
+- `METALIST_HOST=127.0.0.1` (default): bind the main app to a specific interface; use a LAN IP or `0.0.0.0` only for intentional remote access
+- `METALIST_ALLOWED_HOSTS=notes.example.com,192.168.1.20`: comma-separated public/LAN hostnames accepted in HTTP `Host` headers; loopback aliases and a specific non-wildcard `METALIST_HOST` are accepted automatically
 - `METALIST_PORT=8000` (default): bind the main app to a different port
 - `METALIST_HTTPS_PORT=8443`: override the HTTPS port when TLS is enabled
 - `METALIST_TLS_CERT=/path/to/fullchain.pem` + `METALIST_TLS_KEY=/path/to/privkey.pem`: override TLS paths
 - `METALIST_AUTO_GENERATE_TLS=0`: disable automatic creation of the default self-signed TLS pair
 - default TLS paths: `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`
 - `METALIST_FORWARDED_ALLOW_IPS=127.0.0.1,::1` (default): trust proxy headers only from those reverse-proxy IPs
+- `--enable-shell`: opt in to local `@shell` execution for this launch; shell routes require a loopback client and loopback request host, and the capability is never persisted in namespace data
 
 ### Remote Access / HTTPS
-Plain LAN or VPN HTTP works with a normal PyCharm run:
+LAN or VPN access must be enabled explicitly. Prefer binding the machine's specific LAN address, which also adds that address to the accepted-host set:
 ```bash
-metalist
+METALIST_HOST=192.168.1.20 metalist
 ```
-On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://<laptop-ip>:8000` or `https://<laptop-ip>:8443` from the other machine.
+On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://192.168.1.20:8000` or `https://192.168.1.20:8443` from the other machine.
+
+To keep `@shell` available on the host laptop while allowing another laptop to
+use normal MetaList features, bind both interfaces and explicitly allow the LAN
+address:
+
+```bash
+METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=10.0.0.31 \
+metalist --enable-shell
+```
+
+Use `http://127.0.0.1:<namespace-http-port>` on the host laptop when running
+`@shell`. Other devices may use `https://10.0.0.31:<namespace-https-port>`, but
+their shell start/status requests receive `403`.
 
 Namespaced launch example:
 ```bash
@@ -147,6 +181,7 @@ and MetaList will reuse the saved HTTP / HTTPS ports for `work`. The same applie
 Equivalent explicit launch, if you want it:
 ```bash
 METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=192.168.1.20 \
 METALIST_PORT=8000 \
 METALIST_HTTPS_PORT=8443 \
 metalist
@@ -156,6 +191,7 @@ From the other machine, open `https://<laptop-ip>:8443`.
 If you already have a real certificate and key, use the same dual-listener flow:
 ```bash
 METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=192.168.1.20 \
 METALIST_PORT=8000 \
 METALIST_HTTPS_PORT=8443 \
 METALIST_TLS_CERT=/path/to/fullchain.pem \
@@ -175,11 +211,17 @@ When HTTPS is enabled:
 If TLS is terminated by a reverse proxy on the same machine instead, keep MetaList on loopback and let the proxy forward to it:
 ```bash
 METALIST_HOST=127.0.0.1 \
+METALIST_ALLOWED_HOSTS=notes.example.com \
 METALIST_PORT=8000 \
 METALIST_FORWARDED_ALLOW_IPS=127.0.0.1,::1 \
 metalist
 ```
 
+The reverse proxy must preserve the browser-facing `Host` header and set
+`X-Forwarded-Proto`. MetaList never trusts `X-Forwarded-Host`; forwarded
+scheme/client metadata is accepted only from `METALIST_FORWARDED_ALLOW_IPS`.
+Do not widen that list beyond the actual proxy addresses.
+
 ### Legacy Import
 `convert-from-legacy.py` replaces the SQLite database referenced by `app.config.DATABASE_URL`, clears its files/sounds sidecar, and imports notes from a legacy JSON export.
 

{metalist-0.3.11 → metalist-0.3.12}/README.md

@@ -70,8 +70,22 @@ metalist
 ```
 For source-checkout compatibility, `python main.py` performs the same orchestration. Use `metalist work`, `python main.py --namespace work`, or `python main.py work` when you want one foreground namespace process.
 
-`metalist` and explicit single-namespace source runs bind HTTP on `0.0.0.0:8000` by default, matching the old MetaList LAN-friendly behavior.
-On first startup, MetaList also auto-generates a self-signed TLS pair at `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`, then enables HTTPS on `0.0.0.0:8443`. If you already have real PEM files, point `METALIST_TLS_CERT` and `METALIST_TLS_KEY` at them instead. Set `METALIST_AUTO_GENERATE_TLS=0` only if you explicitly want HTTP-only startup.
+Shell execution is disabled by default. To enable `@shell` for every namespace
+started by the top-level orchestrator, use either:
+
+```bash
+metalist --enable-shell
+python main.py --enable-shell
+```
+
+This flag is propagated to every namespace child process. The top-level process
+prints a conspicuous shell-enabled banner before its namespace launch results.
+Use `python main.py work --enable-shell` for one foreground namespace. Shell
+routes remain restricted to loopback clients using a loopback request host,
+even when the rest of MetaList is intentionally exposed to a LAN.
+
+`metalist` and explicit single-namespace source runs bind to loopback at `127.0.0.1:8000` by default. This keeps a normal laptop launch off LAN and public interfaces unless remote access is explicitly configured.
+On first startup, MetaList also auto-generates a self-signed TLS pair at `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`, then enables HTTPS on the same bind host at port `8443`. If you already have real PEM files, point `METALIST_TLS_CERT` and `METALIST_TLS_KEY` at them instead. Set `METALIST_AUTO_GENERATE_TLS=0` only if you explicitly want HTTP-only startup.
 
 Database selection:
 - No explicit namespace on a single-namespace launch: `~/MetaList/namespaces/default/default.metalist.db`
@@ -87,20 +101,36 @@ Useful env flags:
 - `CRASH_SERVER_ON_FAIL=1` (default): fail-fast on validation errors
 - `API_PREFIX=/api2`: override API prefix (client assumes `/api2` by default)
 - `METALIST_NAMESPACE=work`: select `~/MetaList/namespaces/work/work.metalist.db`
-- `METALIST_HOST=0.0.0.0` (default): bind the main app to a different interface such as `127.0.0.1`
+- `METALIST_HOST=127.0.0.1` (default): bind the main app to a specific interface; use a LAN IP or `0.0.0.0` only for intentional remote access
+- `METALIST_ALLOWED_HOSTS=notes.example.com,192.168.1.20`: comma-separated public/LAN hostnames accepted in HTTP `Host` headers; loopback aliases and a specific non-wildcard `METALIST_HOST` are accepted automatically
 - `METALIST_PORT=8000` (default): bind the main app to a different port
 - `METALIST_HTTPS_PORT=8443`: override the HTTPS port when TLS is enabled
 - `METALIST_TLS_CERT=/path/to/fullchain.pem` + `METALIST_TLS_KEY=/path/to/privkey.pem`: override TLS paths
 - `METALIST_AUTO_GENERATE_TLS=0`: disable automatic creation of the default self-signed TLS pair
 - default TLS paths: `~/MetaList/certs/metalist-cert.pem` and `~/MetaList/certs/metalist-key.pem`
 - `METALIST_FORWARDED_ALLOW_IPS=127.0.0.1,::1` (default): trust proxy headers only from those reverse-proxy IPs
+- `--enable-shell`: opt in to local `@shell` execution for this launch; shell routes require a loopback client and loopback request host, and the capability is never persisted in namespace data
 
 ### Remote Access / HTTPS
-Plain LAN or VPN HTTP works with a normal PyCharm run:
+LAN or VPN access must be enabled explicitly. Prefer binding the machine's specific LAN address, which also adds that address to the accepted-host set:
 ```bash
-metalist
+METALIST_HOST=192.168.1.20 metalist
 ```
-On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://<laptop-ip>:8000` or `https://<laptop-ip>:8443` from the other machine.
+On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://192.168.1.20:8000` or `https://192.168.1.20:8443` from the other machine.
+
+To keep `@shell` available on the host laptop while allowing another laptop to
+use normal MetaList features, bind both interfaces and explicitly allow the LAN
+address:
+
+```bash
+METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=10.0.0.31 \
+metalist --enable-shell
+```
+
+Use `http://127.0.0.1:<namespace-http-port>` on the host laptop when running
+`@shell`. Other devices may use `https://10.0.0.31:<namespace-https-port>`, but
+their shell start/status requests receive `403`.
 
 Namespaced launch example:
 ```bash
@@ -118,6 +148,7 @@ and MetaList will reuse the saved HTTP / HTTPS ports for `work`. The same applie
 Equivalent explicit launch, if you want it:
 ```bash
 METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=192.168.1.20 \
 METALIST_PORT=8000 \
 METALIST_HTTPS_PORT=8443 \
 metalist
@@ -127,6 +158,7 @@ From the other machine, open `https://<laptop-ip>:8443`.
 If you already have a real certificate and key, use the same dual-listener flow:
 ```bash
 METALIST_HOST=0.0.0.0 \
+METALIST_ALLOWED_HOSTS=192.168.1.20 \
 METALIST_PORT=8000 \
 METALIST_HTTPS_PORT=8443 \
 METALIST_TLS_CERT=/path/to/fullchain.pem \
@@ -146,11 +178,17 @@ When HTTPS is enabled:
 If TLS is terminated by a reverse proxy on the same machine instead, keep MetaList on loopback and let the proxy forward to it:
 ```bash
 METALIST_HOST=127.0.0.1 \
+METALIST_ALLOWED_HOSTS=notes.example.com \
 METALIST_PORT=8000 \
 METALIST_FORWARDED_ALLOW_IPS=127.0.0.1,::1 \
 metalist
 ```
 
+The reverse proxy must preserve the browser-facing `Host` header and set
+`X-Forwarded-Proto`. MetaList never trusts `X-Forwarded-Host`; forwarded
+scheme/client metadata is accepted only from `METALIST_FORWARDED_ALLOW_IPS`.
+Do not widen that list beyond the actual proxy addresses.
+
 ### Legacy Import
 `convert-from-legacy.py` replaces the SQLite database referenced by `app.config.DATABASE_URL`, clears its files/sounds sidecar, and imports notes from a legacy JSON export.
 

{metalist-0.3.11 → metalist-0.3.12}/app/api/middleware/auth.py

@@ -14,23 +14,28 @@ from app.config import API_PREFIX, TEST_MODE
 
 class AuthMiddleware(BaseHTTPMiddleware):
     """Middleware to check authentication on protected routes."""
-    
-    # Paths that don't require authentication
-    PUBLIC_PATHS = [
+
+    PUBLIC_EXACT_PATHS = frozenset({
+        "/",
         f"{API_PREFIX}/auth/login",
+        f"{API_PREFIX}/auth/login-namespaces",
+        f"{API_PREFIX}/auth/login-namespaces/open",
         f"{API_PREFIX}/auth/status",
         f"{API_PREFIX}/auth/session",
-        f"{API_PREFIX}/auth/namespaces/delete-jobs/",
-        f"{API_PREFIX}/auth/namespaces/rename-jobs/",
-        "/namespace-deleted",
-        "/namespace-renamed",
-        "/static/",  # CSS/JS files needed for login page
         "/favicon.ico",
         "/locked",
-    ]
+        "/namespace-deleted",
+        "/namespace-deleted/open",
+        "/namespace-renamed",
+        "/namespace-renamed/open",
+    } | ({f"{API_PREFIX}/test/reset"} if TEST_MODE else set()))
 
-    if TEST_MODE:
-        PUBLIC_PATHS.append(f"{API_PREFIX}/test/reset")
+    PUBLIC_PREFIX_PATHS = (
+        f"{API_PREFIX}/auth/namespaces/delete-jobs/",
+        f"{API_PREFIX}/auth/namespaces/rename-jobs/",
+        "/static/",  # CSS/JS files needed for login page
+    )
+    assert all(path.endswith("/") for path in PUBLIC_PREFIX_PATHS)
     
     # Paths to suppress verbose logging for (frequent polling endpoints)
     QUIET_PATHS = [
@@ -44,6 +49,14 @@ class AuthMiddleware(BaseHTTPMiddleware):
     ]
     
     # Note: /api/notes/* paths are NOT in this list - they require auth when password is set
+
+    @classmethod
+    def is_public_path(cls, *, path: str) -> bool:
+        if not isinstance(path, str) or not path.startswith("/"):
+            raise TypeError("path must be an absolute URL path")
+        if path in cls.PUBLIC_EXACT_PATHS:
+            return True
+        return any(path.startswith(prefix) for prefix in cls.PUBLIC_PREFIX_PATHS)
     
     async def dispatch(self, request: Request, call_next):
         """Check authentication for protected routes."""
@@ -74,22 +87,9 @@ class AuthMiddleware(BaseHTTPMiddleware):
         if not is_quiet:
             print(f"Middleware checking path: {path}")
         
-        # Skip authentication for public paths
-        public_match = None
-        
-        # Handle exact root path match
-        if path == "/":
-            public_match = "/ (root)"
-        else:
-            # Check other public paths with startswith
-            for public in self.PUBLIC_PATHS:
-                if path.startswith(public):
-                    public_match = public
-                    break
-                
-        if public_match:
+        if self.is_public_path(path=path):
             if not is_quiet:
-                print(f"Path {path} is public (matched '{public_match}'), skipping auth")
+                print(f"Path {path} is explicitly public, skipping auth")
             return await call_next(request)
         
         if not is_quiet:

{metalist-0.3.11 → metalist-0.3.12}/app/api/request_auth.py

@@ -2,8 +2,19 @@ from __future__ import annotations
 
 from fastapi import HTTPException, Request, Response
 
+from app.config import ACTIVE_NAMESPACE
+from app.server_runtime import validate_namespace
 
-AUTH_COOKIE_NAME = "metalist_auth"
+
+AUTH_COOKIE_PREFIX = "metalist_auth"
+
+
+def auth_cookie_name_for_namespace(namespace: str) -> str:
+    normalized_namespace = validate_namespace(namespace=namespace)
+    return f"{AUTH_COOKIE_PREFIX}_{normalized_namespace}"
+
+
+AUTH_COOKIE_NAME = auth_cookie_name_for_namespace(ACTIVE_NAMESPACE)
 
 
 def read_request_auth_token(request: Request) -> tuple[str | None, str | None]:

{metalist-0.3.11 → metalist-0.3.12}/app/api/routes/auth.py

@@ -56,6 +56,7 @@ from app.server_runtime import load_all_namespace_launch_profiles
 from app.server_runtime import resolve_namespace_directory
 from app.server_runtime import resolve_namespaced_database_path
 from app.server_runtime import validate_namespace
+from app.security.sensitive_logging import traceback_frame_summary
 from app.services.encryption import EncryptionService
 from app.services.tokens import token_service
 from app.services.note_store import store as note_store
@@ -443,11 +444,11 @@ def _on_hydration_done(future: Future) -> None:
         return
     error = future.exception()
     if error is not None:
-        error_message = f"{type(error).__name__}: {error}"
+        error_message = type(error).__name__
         logger.error(
-            "Hydration worker failed: %s",
+            "Hydration worker failed: %s frames=%s",
             error_message,
-            exc_info=(type(error), error, error.__traceback__),
+            traceback_frame_summary(error.__traceback__),
         )
         hydration_state.fail(error_message)
 
@@ -540,17 +541,9 @@ def _client_info(request: Request) -> str:
 
 
 def _login_rate_limit_key(request: Request) -> str:
-    forwarded_for = request.headers.get("x-forwarded-for")
-    if forwarded_for is not None:
-        forwarded_for = forwarded_for.strip()
-    if forwarded_for:
-        first_hop = forwarded_for.split(",")[0].strip()
-        if first_hop:
-            return f"ip:{first_hop}"
-    if request.client and request.client.host:
-        return f"ip:{request.client.host}"
-    user_agent = request.headers.get("user-agent", "Unknown")
-    return f"ua:{user_agent[:128]}"
+    if request.client is None or request.client.host == "":
+        raise RuntimeError("Login request is missing client metadata")
+    return f"ip:{request.client.host}"
 
 
 def _require_tab_id(

{metalist-0.3.11 → metalist-0.3.12}/app/api/routes/backups.py

@@ -870,19 +870,21 @@ def list_backups(token: Annotated[str, Depends(_require_auth)]):
 
 @router.post("/run", response_model=BackupRunResponse)
 @transactional_route
-def run_backup(token: Annotated[str, Depends(_require_auth)]):
-    settings = load_backup_settings(token=token)
-    folder_path = settings["folder_path"]
-    selected_namespaces = settings["selected_namespaces"]
-    retention_count = settings["retention_count"]
-    if not isinstance(folder_path, str):
-        raise RuntimeError("backup settings folder_path must be a string")
-    if not isinstance(selected_namespaces, list):
-        raise RuntimeError("backup settings selected_namespaces must be a list")
-    if not isinstance(retention_count, int) or retention_count <= 0:
-        raise RuntimeError("backup settings retention_count must be a positive integer")
+def run_backup(
+    payload: BackupSettingsUpdateRequest,
+    token: Annotated[str, Depends(_require_auth)],
+):
+    folder_path = _prepare_folder_backup_directory_for_settings(
+        folder_path=payload.folder_path,
+    )
     normalized_selected_namespaces = _filter_deleted_selected_namespaces(
-        selected_namespaces=selected_namespaces,
+        selected_namespaces=payload.selected_namespaces,
+    )
+    update_backup_settings(
+        token=token,
+        folder_path=folder_path,
+        selected_namespaces=normalized_selected_namespaces,
+        retention_count=payload.retention_count,
     )
 
     folder_directory = _normalize_folder_backup_path(folder_path=folder_path)
@@ -895,7 +897,7 @@ def run_backup(token: Annotated[str, Depends(_require_auth)]):
         database_path = resolve_namespaced_database_path(namespace=namespace)
         backup_info = create_timestamped_backup_for_paths(database_path, folder_directory)
         current_folder_backups = list_backups_in_directory(folder_directory, database_path=database_path)
-        folder_delete_count = len(current_folder_backups) - retention_count
+        folder_delete_count = len(current_folder_backups) - payload.retention_count
         deleted_folder_count = 0
         if folder_delete_count > 0:
             deleted_folder_count = len(

{metalist-0.3.11 → metalist-0.3.12}/app/api/routes/notes.py

@@ -71,6 +71,7 @@ from app.services.undo_state import reset_undo_stack
 from app.usecases.prioritize import list_prioritize_tag_suggestions
 from app.services.selected_text_tag import SelectedTextTagValidationError
 from app.api.request_auth import require_request_auth_token
+from app.security.shell_execution import is_loopback_host
 
 
 logger = logging.getLogger(__name__)
@@ -93,6 +94,22 @@ def _require_note_present(note_id: str, *, context: str) -> None:
     raise HTTPException(status_code=404, detail=f"Note not found: {note_id}")
 
 
+def _require_loopback_shell_request(request: Request) -> None:
+    if not isinstance(request, Request):
+        raise TypeError("request must be a Request")
+    if request.client is None or not is_loopback_host(host=request.client.host):
+        raise HTTPException(
+            status_code=403,
+            detail="Shell execution is restricted to loopback clients",
+        )
+    request_hostname = request.url.hostname
+    if request_hostname is None or not is_loopback_host(host=request_hostname):
+        raise HTTPException(
+            status_code=403,
+            detail="Shell execution requires a loopback request host",
+        )
+
+
 def _resolve_tab_sort_mode(tab_id: object) -> str:
     if tab_id is not None and (not isinstance(tab_id, str) or tab_id == ""):
         raise TypeError("tabId must be a non-empty string")
@@ -883,7 +900,8 @@ def resize_note_image(request: Request, note_id: str, body: dict):
 
 @router.post("/notes/{note_id}/run-shell")
 @transactional_route
-def run_shell_endpoint(note_id: str, body: dict) -> Dict[str, object]:
+def run_shell_endpoint(request: Request, note_id: str, body: dict) -> Dict[str, object]:
+    _require_loopback_shell_request(request)
     _require_note_present(note_id, context="notes.run-shell")
     timeout_seconds = body["timeoutSeconds"]
     cmd = CmdRunShellStart(
@@ -894,7 +912,8 @@ def run_shell_endpoint(note_id: str, body: dict) -> Dict[str, object]:
 
 
 @router.get("/notes/{note_id}/run-shell/{run_id}")
-def run_shell_status_endpoint(note_id: str, run_id: str) -> Dict[str, object]:
+def run_shell_status_endpoint(request: Request, note_id: str, run_id: str) -> Dict[str, object]:
+    _require_loopback_shell_request(request)
     run_capture = CapturedExceptionContext(RuntimeError, TypeError, ValueError)
     result: Dict[str, object] | None = None
     with run_capture:

metalist-0.3.12/app/api/routes/remote_images.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request, Response
+from pydantic import BaseModel, Field
+
+from app.api.request_auth import require_request_auth_token
+from app.api.transactions import transactional_route
+from app.services.exception_capture import CapturedExceptionContext
+from app.services.remote_image_proxy import (
+    RemoteImageFetchError,
+    fetch_remote_image,
+    remote_image_proxy_registry,
+)
+
+
+router = APIRouter(prefix="/remote-images", tags=["remote-images"])
+
+
+class RemoteImageRegistrationRequest(BaseModel):
+    source_urls: list[str] = Field(min_length=1, max_length=100)
+
+
+class RemoteImageRegistrationEntryResponse(BaseModel):
+    source_url: str
+    proxy_path: str
+
+
+class RemoteImageRegistrationResponse(BaseModel):
+    images: list[RemoteImageRegistrationEntryResponse]
+
+
+@router.post("/registrations", response_model=RemoteImageRegistrationResponse)
+@transactional_route
+def register_remote_images(
+    request: Request,
+    registration: RemoteImageRegistrationRequest,
+) -> RemoteImageRegistrationResponse:
+    require_request_auth_token(request)
+    images: list[RemoteImageRegistrationEntryResponse] = []
+    for source_url in registration.source_urls:
+        registration_capture = CapturedExceptionContext(ValueError)
+        token = None
+        with registration_capture:
+            token = remote_image_proxy_registry.register(source_url)
+        if registration_capture.captured_exception is not None:
+            raise HTTPException(
+                status_code=422,
+                detail="Remote image URL must use HTTP or HTTPS",
+            )
+        if token is None:
+            raise RuntimeError("Remote image registration completed without a token")
+        images.append(
+            RemoteImageRegistrationEntryResponse(
+                source_url=source_url,
+                proxy_path=f"/api2/remote-images/{token}",
+            )
+        )
+    return RemoteImageRegistrationResponse(images=images)
+
+
+@router.get("/{proxy_token}")
+def proxy_remote_image(request: Request, proxy_token: str) -> Response:
+    require_request_auth_token(request)
+    resolve_capture = CapturedExceptionContext(KeyError)
+    source_url = None
+    with resolve_capture:
+        source_url = remote_image_proxy_registry.resolve(proxy_token)
+    if resolve_capture.captured_exception is not None:
+        raise HTTPException(status_code=404, detail="Remote image reference not found")
+    if source_url is None:
+        raise RuntimeError("Remote image proxy resolution completed without a source URL")
+
+    fetch_capture = CapturedExceptionContext(RemoteImageFetchError)
+    payload = None
+    with fetch_capture:
+        payload = fetch_remote_image(source_url)
+    if fetch_capture.captured_exception is not None:
+        raise HTTPException(status_code=502, detail="Remote image unavailable")
+    if payload is None:
+        raise RuntimeError("Remote image fetch completed without a payload")
+    return Response(
+        content=payload.content,
+        media_type=payload.mime_type,
+        headers={
+            "Cache-Control": "no-store, private",
+            "Cross-Origin-Resource-Policy": "same-origin",
+        },
+    )

{metalist-0.3.11 → metalist-0.3.12}/app/config.py

@@ -69,6 +69,9 @@ KDF_MIN_PARALLELISM = 1
 KDF_MAX_PARALLELISM = 16
 KDF_ALGORITHM = "ARGON2ID"
 VAULT_VERSION = 3
+PASSWORD_MIN_LENGTH = 12
+PASSWORD_MAX_LENGTH = 72
+PASSWORD_MIN_ZXCVBN_SCORE = 3
 
 # Login brute-force mitigation
 LOGIN_RATE_LIMIT_MAX_ATTEMPTS = _env_int("LOGIN_RATE_LIMIT_MAX_ATTEMPTS", 5)
@@ -83,6 +86,8 @@ SECURITY_REQUIRE_MACOS_NO_HIBERNATION = _env_flag("SECURITY_REQUIRE_MACOS_NO_HIB
 assert KDF_MIN_TIME_COST <= KDF_TIME_COST <= KDF_MAX_TIME_COST
 assert KDF_MIN_MEMORY_COST_KIB <= KDF_MEMORY_COST_KIB <= KDF_MAX_MEMORY_COST_KIB
 assert KDF_MIN_PARALLELISM <= KDF_PARALLELISM <= KDF_MAX_PARALLELISM
+assert 0 < PASSWORD_MIN_LENGTH <= PASSWORD_MAX_LENGTH
+assert 0 <= PASSWORD_MIN_ZXCVBN_SCORE <= 4
 assert MAX_SEARCH_SUGGESTIONS > 0
 assert MAX_TAG_SUGGESTIONS > 0
 assert LOGIN_RATE_LIMIT_MAX_ATTEMPTS > 0

{metalist-0.3.11 → metalist-0.3.12}/app/db/file_session.py

@@ -108,9 +108,9 @@ class FileSession:
                 extra={"stack": stack},
             )
         else:
-            logger.opt(exception=True).error(
+            logger.error(
                 "FATAL: file DB rollback executed; crashing process",
-                extra={"stack": stack},
+                extra={"stack": stack, "error_type": exc_type.__name__},
             )
         sys.stderr.write("FATAL: file DB rollback executed; crashing process\n")
         sys.stderr.flush()

{metalist-0.3.11 → metalist-0.3.12}/app/db/migrations.py

@@ -6,12 +6,11 @@ from collections.abc import Callable
 from dataclasses import dataclass
 import sqlite3
 
+from app.db.version import CURRENT_DATABASE_VERSION
+from app.db.schema import create_namespace_content_migrations_table
 from app.services.encryption import EncryptionService
 
 
-CURRENT_DATABASE_VERSION = 1
-
-
 @dataclass(frozen=True, slots=True)
 class MigrationResult:
     initial_version: int
@@ -124,11 +123,22 @@ def _migration_0_to_1(
     return rewritten_count
 
 
+def _migration_1_to_2(
+    *,
+    connection: sqlite3.Connection,
+    encryption_enabled: bool,  # noqa: ARG001
+    encryption_service: EncryptionService | None,  # noqa: ARG001
+) -> int:
+    create_namespace_content_migrations_table(connection)
+    return 0
+
+
 _MIGRATIONS: dict[
     int,
     Callable[..., int],
 ] = {
     0: _migration_0_to_1,
+    1: _migration_1_to_2,
 }