MetaList 0.3.10__tar.gz → 0.3.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.3.10
+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"
@@ -35,7 +39,7 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Rich text editing (ContentEditable) with image support
 - Drag-and-drop note reordering
 - Real-time content saving
-- Keyboard shortcuts (press `?` in the app)
+- Keyboard shortcuts / cheatsheet (press `?` in the app)
 - Linked-list ordering model for efficient reorders
 - Optional password protection + encryption at rest (AES-GCM)
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
@@ -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,26 +134,40 @@ 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
-- `MCP_AGENT_WEB_PORT=8765` (default): bind the MCP sidecar web UI to a different port
 - `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
-- `MCP_AGENT_PUBLIC_ORIGIN=https://notes.example.com:8765`: public origin for the MCP sidecar redirect when it is exposed behind HTTPS or a separate hostname/port
+- `--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://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
 ```
-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.
+
+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
-metalist --namespace work --port 8001 --mcp-port 8766
+metalist --namespace work --port 8001
 ```
 This starts a separate process backed by `~/MetaList/namespaces/work/work.metalist.db` on `http://127.0.0.1:8001`.
 Its backup snapshots live under `~/MetaList/namespaces/work/backups/` with filenames like `work-<timestamp>.metalist-backup.tar.gz`. New backups are versioned `.tar.gz` workspace archives; legacy `.bak` backups remain restorable.
@@ -144,11 +176,12 @@ After you launch a namespace once with explicit ports, MetaList remembers them i
 ```bash
 metalist work
 ```
-and MetaList will reuse the saved HTTP / HTTPS / MCP sidecar ports for `work`. The same applies to the default namespace: `metalist` will reuse the saved default-namespace profile.
+and MetaList will reuse the saved HTTP / HTTPS ports for `work`. The same applies to the default namespace: `metalist` will reuse the saved default-namespace profile.
 
 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
@@ -158,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 \
@@ -177,67 +211,16 @@ 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
 ```
 
-If you do not need the MCP sidecar remotely, disable it:
-```bash
-MCP_AGENT_WEB_ENABLED=0 metalist
-```
-
-### MCP (Phase 1 Read-Only)
-MCP is available automatically when you run:
-```bash
-metalist
-```
-
-`metalist` also auto-starts the agent web app sidecar and prints:
-- `Agent web app: http://127.0.0.1:8765`
-- The sidecar default MCP URL follows the resolved MetaList HTTP port for the current process.
-- Use `--mcp-port` when you want multiple MetaList instances to auto-start sidecars without colliding on `8765`.
-- On startup, local Ollama (`127.0.0.1`) is reset by default so a fresh runner is used.
-- Sidecar Ollama auto-start uses `OLLAMA_CONTEXT_LENGTH=16384` by default.
-
-Manual web mode (optional):
-```bash
-metalist-mcp web --port 8765
-```
-Then open `http://127.0.0.1:8765`.
-
-Run direct MCP CLI calls:
-```bash
-metalist-mcp cli tools/list
-metalist-mcp cli tools/call health_check '{}'
-```
-
-Compatibility shortcut (still works):
-```bash
-python mcp_client.py tools/list
-```
-
-Disable auto sidecar if needed:
-```bash
-MCP_AGENT_WEB_ENABLED=0 metalist
-```
-
-Control Ollama startup behavior:
-```bash
-# disable Ollama reset-on-start (default is enabled)
-MCP_AGENT_RESET_OLLAMA_ON_START=0 metalist
-
-# override auto-start context length (default 16384)
-MCP_AGENT_OLLAMA_CONTEXT_LENGTH=32768 metalist
-```
-
-Optional: direct stdio transport (advanced/manual):
-```bash
-python -m app.mcp
-```
-
-Tool catalog and schemas:
-- `docs/mcp_tools.md`
+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.
@@ -254,7 +237,7 @@ Target a namespaced database during import:
 convert-from-legacy.py --namespace work --input /path/to/legacy-export.json
 ```
 
-If `--namespace`, `--port`, `--https-port`, or `--mcp-port` are omitted, the import script prompts for them and saves the resulting launch profile inside the target namespace DB. That means a one-time import into `work` can immediately seed later shorthand launches like `metalist work`.
+If `--namespace`, `--port`, or `--https-port` are omitted, the import script prompts for them and saves the resulting launch profile inside the target namespace DB. That means a one-time import into `work` can immediately seed later shorthand launches like `metalist work`.
 
 ### Publishing
 For the real user-facing install flow:

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

@@ -6,7 +6,7 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Rich text editing (ContentEditable) with image support
 - Drag-and-drop note reordering
 - Real-time content saving
-- Keyboard shortcuts (press `?` in the app)
+- Keyboard shortcuts / cheatsheet (press `?` in the app)
 - Linked-list ordering model for efficient reorders
 - Optional password protection + encryption at rest (AES-GCM)
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
@@ -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,26 +101,40 @@ 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
-- `MCP_AGENT_WEB_PORT=8765` (default): bind the MCP sidecar web UI to a different port
 - `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
-- `MCP_AGENT_PUBLIC_ORIGIN=https://notes.example.com:8765`: public origin for the MCP sidecar redirect when it is exposed behind HTTPS or a separate hostname/port
+- `--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://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
 ```
-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.
+
+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
-metalist --namespace work --port 8001 --mcp-port 8766
+metalist --namespace work --port 8001
 ```
 This starts a separate process backed by `~/MetaList/namespaces/work/work.metalist.db` on `http://127.0.0.1:8001`.
 Its backup snapshots live under `~/MetaList/namespaces/work/backups/` with filenames like `work-<timestamp>.metalist-backup.tar.gz`. New backups are versioned `.tar.gz` workspace archives; legacy `.bak` backups remain restorable.
@@ -115,11 +143,12 @@ After you launch a namespace once with explicit ports, MetaList remembers them i
 ```bash
 metalist work
 ```
-and MetaList will reuse the saved HTTP / HTTPS / MCP sidecar ports for `work`. The same applies to the default namespace: `metalist` will reuse the saved default-namespace profile.
+and MetaList will reuse the saved HTTP / HTTPS ports for `work`. The same applies to the default namespace: `metalist` will reuse the saved default-namespace profile.
 
 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
@@ -129,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 \
@@ -148,67 +178,16 @@ 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
 ```
 
-If you do not need the MCP sidecar remotely, disable it:
-```bash
-MCP_AGENT_WEB_ENABLED=0 metalist
-```
-
-### MCP (Phase 1 Read-Only)
-MCP is available automatically when you run:
-```bash
-metalist
-```
-
-`metalist` also auto-starts the agent web app sidecar and prints:
-- `Agent web app: http://127.0.0.1:8765`
-- The sidecar default MCP URL follows the resolved MetaList HTTP port for the current process.
-- Use `--mcp-port` when you want multiple MetaList instances to auto-start sidecars without colliding on `8765`.
-- On startup, local Ollama (`127.0.0.1`) is reset by default so a fresh runner is used.
-- Sidecar Ollama auto-start uses `OLLAMA_CONTEXT_LENGTH=16384` by default.
-
-Manual web mode (optional):
-```bash
-metalist-mcp web --port 8765
-```
-Then open `http://127.0.0.1:8765`.
-
-Run direct MCP CLI calls:
-```bash
-metalist-mcp cli tools/list
-metalist-mcp cli tools/call health_check '{}'
-```
-
-Compatibility shortcut (still works):
-```bash
-python mcp_client.py tools/list
-```
-
-Disable auto sidecar if needed:
-```bash
-MCP_AGENT_WEB_ENABLED=0 metalist
-```
-
-Control Ollama startup behavior:
-```bash
-# disable Ollama reset-on-start (default is enabled)
-MCP_AGENT_RESET_OLLAMA_ON_START=0 metalist
-
-# override auto-start context length (default 16384)
-MCP_AGENT_OLLAMA_CONTEXT_LENGTH=32768 metalist
-```
-
-Optional: direct stdio transport (advanced/manual):
-```bash
-python -m app.mcp
-```
-
-Tool catalog and schemas:
-- `docs/mcp_tools.md`
+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.
@@ -225,7 +204,7 @@ Target a namespaced database during import:
 convert-from-legacy.py --namespace work --input /path/to/legacy-export.json
 ```
 
-If `--namespace`, `--port`, `--https-port`, or `--mcp-port` are omitted, the import script prompts for them and saves the resulting launch profile inside the target namespace DB. That means a one-time import into `work` can immediately seed later shorthand launches like `metalist work`.
+If `--namespace`, `--port`, or `--https-port` are omitted, the import script prompts for them and saves the resulting launch profile inside the target namespace DB. That means a one-time import into `work` can immediately seed later shorthand launches like `metalist work`.
 
 ### Publishing
 For the real user-facing install flow:

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

@@ -7,32 +7,35 @@ from app.api.request_auth import read_request_auth_token
 from app.services.tokens import token_service
 from app.services.auth_service import AuthService
 from app.services.maintenance_mode import maintenance_service
+from app.services.runtime_lock import purge_decrypted_runtime_state
 from app.models.database import SafeSession
 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/",
-        f"{API_PREFIX}/mcp",
-        "/mcp-client-v2",
-        "/mcp-client",
-        "/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 = [
@@ -46,11 +49,22 @@ 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."""
         path = request.url.path
 
+        if not token_service.has_active_tokens():
+            purge_decrypted_runtime_state()
+
         # Block any v1 API usage with an explicit 410 Gone (no DB access)
         if path.startswith('/api') and not (path.startswith(API_PREFIX) or path == API_PREFIX):
             ref = request.headers.get('referer', '-')
@@ -73,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.10 → 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.10 → metalist-0.3.12}/app/api/routes/auth.py

@@ -52,9 +52,11 @@ from app.services.namespace_switcher import save_namespace_port_profiles
 from app.services.namespace_deletion_jobs import load_namespace_deletion_job
 from app.services.namespace_rename_jobs import load_namespace_rename_job
 from app.server_runtime import NamespaceLaunchProfile
+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
@@ -67,6 +69,7 @@ from app.services.link_titles import link_title_store
 from app.services.reminders import reminder_store
 from app.services.search_history import search_history_store
 from app.services.sound_storage import sound_store
+from app.services.runtime_lock import purge_decrypted_runtime_state
 from app.services.hydration_state import hydration_state
 from app.services.file_registry import file_registry
 from app.services.file_storage import bootstrap_file_registry
@@ -441,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)
 
@@ -538,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(
@@ -681,8 +676,9 @@ def logout(
     token: Annotated[str, Depends(_require_auth)],
 ):
     token_service.revoke_token(token)
-    clear_all_locks()
-    clear_encryption_key()
+    if not purge_decrypted_runtime_state():
+        clear_all_locks()
+        clear_encryption_key()
     clear_auth_cookie(response=response)
     return {"message": "Logout successful"}
 
@@ -882,7 +878,6 @@ def open_namespace(
     namespace = _require_string_field(body, "namespace")
     port = _require_int_field(body, "port")
     https_port = _optional_int_field(body, "https_port")
-    mcp_port = _require_int_field(body, "mcp_port")
     launch_capture = CapturedExceptionContext(
         RuntimeError,
         ValueError,
@@ -897,7 +892,6 @@ def open_namespace(
             namespace=namespace,
             port=port,
             https_port=https_port,
-            mcp_port=mcp_port,
         )
     if launch_capture.captured_exception is not None:
         exc = launch_capture.captured_exception
@@ -912,7 +906,6 @@ def open_namespace(
             "namespace": result.saved_profile.namespace,
             "port": result.saved_profile.port,
             "https_port": result.saved_profile.https_port,
-            "mcp_port": result.saved_profile.mcp_port,
         },
         "saved_for_next_launch": result.saved_for_next_launch,
         "message": result.message,
@@ -927,6 +920,10 @@ def save_namespace_ports(
 ):
     body = _require_body_object(payload)
     raw_profiles = _require_list_field(body, "profiles")
+    saved_profiles = {
+        profile.namespace: profile
+        for profile in load_all_namespace_launch_profiles()
+    }
     requested_profiles: list[NamespaceLaunchProfile] = []
     for raw_profile in raw_profiles:
         if not isinstance(raw_profile, dict):
@@ -934,13 +931,16 @@ def save_namespace_ports(
         namespace = _require_string_field(raw_profile, "namespace")
         port = _require_int_field(raw_profile, "port")
         https_port = _optional_int_field(raw_profile, "https_port")
-        mcp_port = _require_int_field(raw_profile, "mcp_port")
+        saved_profile = saved_profiles.get(namespace)
+        legacy_mcp_port = None
+        if saved_profile is not None:
+            legacy_mcp_port = saved_profile.mcp_port
         requested_profiles.append(
             NamespaceLaunchProfile(
                 namespace=namespace,
                 port=port,
                 https_port=https_port,
-                mcp_port=mcp_port,
+                mcp_port=legacy_mcp_port,
             )
         )
 
@@ -968,7 +968,6 @@ def save_namespace_ports(
                 "namespace": profile.namespace,
                 "port": profile.port,
                 "https_port": profile.https_port,
-                "mcp_port": profile.mcp_port,
             }
             for profile in result.saved_profiles
         ],