MetaList 0.3.4__tar.gz → 0.3.7__tar.gz

{metalist-0.3.4 → metalist-0.3.7}/MANIFEST.in

@@ -1,3 +1,4 @@
 recursive-include app/static *
 recursive-include app/templates *.html
+prune app/__pycache__
 global-exclude .DS_Store

{metalist-0.3.4/metalist.egg-info → metalist-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.3.4
+Version: 0.3.7
 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
@@ -234,9 +234,9 @@ Tool catalog and schemas:
 - `docs/mcp_tools.md`
 
 ### Legacy Import
-`convert-from-legacy.py` replaces the SQLite database referenced by `app.config.DATABASE_URL` and imports notes from a legacy JSON export.
+`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.
 
-This is destructive. It deletes the existing DB file before rebuilding it.
+This is destructive. It deletes the existing notes DB and related files/sounds DB before rebuilding the namespace.
 
 Example usage:
 ```bash
@@ -263,11 +263,11 @@ This repo now packages itself under the PyPI distribution name `metalist`. Curre
 
 Recommended release path:
 1. In the existing PyPI project `metalist`, configure GitHub Trusted Publishing for `evolvingstuff/metalist` and the workflow file `.github/workflows/publish-pypi.yml`.
-2. Push a tag such as `v0.3.4`.
+2. Push a tag such as `v0.3.5`.
 3. After the GitHub Actions workflow completes, users can run it with `uvx metalist`, install it persistently with `uv tool install metalist`, or install it with `pip install metalist`.
 
 If `--input` is omitted, a file picker opens (when `tkinter` is available).
-Notes tagged with `@implies` are converted into ontology rules and are not imported as notes.
+Notes tagged with `@implies` are converted into ontology rules and are not imported as notes. Legacy rules that are invalid under the current ontology grammar are reported and skipped while valid rules continue importing.
 
 ### Run Tests
 

{metalist-0.3.4 → metalist-0.3.7}/README.md

@@ -205,9 +205,9 @@ Tool catalog and schemas:
 - `docs/mcp_tools.md`
 
 ### Legacy Import
-`convert-from-legacy.py` replaces the SQLite database referenced by `app.config.DATABASE_URL` and imports notes from a legacy JSON export.
+`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.
 
-This is destructive. It deletes the existing DB file before rebuilding it.
+This is destructive. It deletes the existing notes DB and related files/sounds DB before rebuilding the namespace.
 
 Example usage:
 ```bash
@@ -234,11 +234,11 @@ This repo now packages itself under the PyPI distribution name `metalist`. Curre
 
 Recommended release path:
 1. In the existing PyPI project `metalist`, configure GitHub Trusted Publishing for `evolvingstuff/metalist` and the workflow file `.github/workflows/publish-pypi.yml`.
-2. Push a tag such as `v0.3.4`.
+2. Push a tag such as `v0.3.5`.
 3. After the GitHub Actions workflow completes, users can run it with `uvx metalist`, install it persistently with `uv tool install metalist`, or install it with `pip install metalist`.
 
 If `--input` is omitted, a file picker opens (when `tkinter` is available).
-Notes tagged with `@implies` are converted into ontology rules and are not imported as notes.
+Notes tagged with `@implies` are converted into ontology rules and are not imported as notes. Legacy rules that are invalid under the current ontology grammar are reported and skipped while valid rules continue importing.
 
 ### Run Tests
 

{metalist-0.3.4 → metalist-0.3.7}/app/api/middleware/auth.py

@@ -20,10 +20,12 @@ class AuthMiddleware(BaseHTTPMiddleware):
         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",

{metalist-0.3.4 → metalist-0.3.7}/app/api/routes/auth.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import secrets
 import sqlite3
 from fastapi import APIRouter, Depends, Header, HTTPException, Request, Response
@@ -46,8 +47,10 @@ from app.services.namespace_switcher import delete_current_namespace
 from app.services.namespace_switcher import delete_namespace
 from app.services.namespace_switcher import open_login_namespace
 from app.services.namespace_switcher import open_or_launch_namespace
+from app.services.namespace_switcher import rename_current_namespace
 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 resolve_namespace_directory
 from app.server_runtime import resolve_namespaced_database_path
@@ -88,6 +91,7 @@ from app.services.client_state_service import save_command_palette_usage
 
 
 router = APIRouter(prefix="/auth", tags=["auth2"])
+logger = logging.getLogger(__name__)
 
 
 class LoginRequest(BaseModel):
@@ -437,7 +441,13 @@ def _on_hydration_done(future: Future) -> None:
         return
     error = future.exception()
     if error is not None:
-        hydration_state.fail(str(error))
+        error_message = f"{type(error).__name__}: {error}"
+        logger.error(
+            "Hydration worker failed: %s",
+            error_message,
+            exc_info=(type(error), error, error.__traceback__),
+        )
+        hydration_state.fail(error_message)
 
 
 def _start_hydration(*, first_load: bool, rebuild_required: bool) -> None:
@@ -582,6 +592,15 @@ def _require_string_field(payload: dict[str, object], field_name: str) -> str:
     return value
 
 
+def _require_string_field_allow_empty(payload: dict[str, object], field_name: str) -> str:
+    if field_name not in payload:
+        raise HTTPException(status_code=400, detail=f"{field_name} is required")
+    value = payload[field_name]
+    if not isinstance(value, str):
+        raise HTTPException(status_code=400, detail=f"{field_name} must be a string")
+    return value
+
+
 def _require_int_field(payload: dict[str, object], field_name: str) -> int:
     if field_name not in payload:
         raise HTTPException(status_code=400, detail=f"{field_name} is required")
@@ -960,7 +979,8 @@ def save_namespace_ports(
 def _delete_namespace_from_body(*, body: dict[str, object], target_namespace: str) -> dict[str, object]:
     normalized_target_namespace = validate_namespace(namespace=target_namespace)
     confirmed_namespace = _require_string_field(body, "confirmed_namespace")
-    current_password = _require_string_field(body, "current_password")
+    current_password = _require_string_field_allow_empty(body, "current_password")
+    redirect_namespace = _require_string_field(body, "redirect_namespace")
 
     if _namespace_requires_password(namespace=normalized_target_namespace):
         _verify_namespace_password(
@@ -981,6 +1001,7 @@ def _delete_namespace_from_body(*, body: dict[str, object], target_namespace: st
             current_namespace=ACTIVE_NAMESPACE,
             target_namespace=normalized_target_namespace,
             confirmed_namespace=confirmed_namespace,
+            redirect_namespace=redirect_namespace,
         )
     if delete_capture.captured_exception is not None:
         exc = delete_capture.captured_exception
@@ -1011,11 +1032,33 @@ def namespace_delete_preflight(
     target_requires_password = False
     if target_exists:
         target_requires_password = _namespace_requires_password(namespace=target_namespace)
+    catalog = build_namespace_catalog(
+        environ=os.environ,
+        current_namespace=ACTIVE_NAMESPACE,
+    )
+    raw_namespaces = catalog["namespaces"]
+    if not isinstance(raw_namespaces, list):
+        raise RuntimeError("Namespace catalog missing namespaces")
+    redirect_namespaces: list[str] = []
+    for raw_entry in raw_namespaces:
+        if not isinstance(raw_entry, dict):
+            raise RuntimeError("Namespace catalog entry must be an object")
+        namespace = raw_entry["namespace"]
+        if not isinstance(namespace, str) or namespace == "":
+            raise RuntimeError("Namespace catalog entry missing namespace")
+        if namespace != target_namespace:
+            redirect_namespaces.append(namespace)
+    redirect_namespaces.sort()
+    recreates_default = target_namespace == ACTIVE_NAMESPACE and len(redirect_namespaces) == 0
+    if recreates_default:
+        redirect_namespaces.append("default")
     return {
         "target_namespace": target_namespace,
         "target_exists": target_exists,
         "target_requires_password": target_requires_password,
         "is_current_namespace": target_namespace == ACTIVE_NAMESPACE,
+        "redirect_namespaces": redirect_namespaces,
+        "recreates_default": recreates_default,
     }
 
 
@@ -1046,6 +1089,41 @@ def delete_active_namespace(
     )
 
 
+@router.post("/namespaces/rename-current")
+@transactional_route
+def rename_active_namespace(
+    payload: dict[str, object],
+    token: Annotated[str, Depends(_require_auth)],
+):
+    body = _require_body_object(payload)
+    target_namespace = _require_string_field(body, "target_namespace")
+    rename_capture = CapturedExceptionContext(
+        RuntimeError,
+        ValueError,
+        TypeError,
+        FileNotFoundError,
+    )
+    result = None
+    with rename_capture:
+        result = rename_current_namespace(
+            environ=os.environ,
+            current_namespace=ACTIVE_NAMESPACE,
+            target_namespace=target_namespace,
+        )
+    if rename_capture.captured_exception is not None:
+        exc = rename_capture.captured_exception
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if result is None:
+        raise RuntimeError("Namespace rename did not return a result")
+    return {
+        "source_namespace": result.source_namespace,
+        "target_namespace": result.target_namespace,
+        "redirect_url": result.redirect_url,
+        "rename_job_id": result.rename_job_id,
+        "message": result.message,
+    }
+
+
 @router.get("/namespaces/delete-jobs/{job_id}")
 def namespace_delete_job_status(
     job_id: str,
@@ -1067,6 +1145,25 @@ def namespace_delete_job_status(
     return job_record
 
 
+@router.get("/namespaces/rename-jobs/{job_id}")
+def namespace_rename_job_status(job_id: str):
+    job_record_capture = CapturedExceptionContext(
+        RuntimeError,
+        TypeError,
+        ValueError,
+        FileNotFoundError,
+    )
+    job_record: dict[str, object] | None = None
+    with job_record_capture:
+        job_record = load_namespace_rename_job(job_id=job_id)
+    if job_record_capture.captured_exception is not None:
+        exc = job_record_capture.captured_exception
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if job_record is None:
+        raise HTTPException(status_code=404, detail=f"Namespace rename job not found: {job_id}")
+    return job_record
+
+
 @router.post("/hydrate", response_model=HydrationStatusResponse)
 @transactional_route
 def hydrate_cache(

{metalist-0.3.4 → metalist-0.3.7}/app/api/routes/backups.py

@@ -35,6 +35,7 @@ from app.server_runtime import NamespaceLaunchProfile
 from app.server_runtime import _DEFAULT_HTTP_PORT
 from app.server_runtime import _DEFAULT_MCP_AGENT_WEB_PORT
 from app.server_runtime import load_all_namespace_launch_profiles
+from app.server_runtime import load_namespace_launch_profile
 from app.server_runtime import resolve_namespace_directory
 from app.server_runtime import resolve_namespaced_database_path
 from app.server_runtime import resolve_namespaces_directory
@@ -125,6 +126,7 @@ class BackupRestorePreflightResponse(BaseModel):
     backup_namespace: str
     target_namespace: str
     same_namespace: bool
+    target_is_active: bool
     target_exists: bool
     target_requires_password: bool
     restored_profile: BackupRestoreLaunchProfileResponse | None
@@ -699,6 +701,48 @@ def _response_profile_from_backup_profile(
     )
 
 
+def _required_existing_target_launch_profile(*, target_namespace: str) -> BackupLaunchProfile:
+    profile = load_namespace_launch_profile(namespace=target_namespace)
+    if profile is None:
+        raise RuntimeError(f"Existing target namespace has no saved launch profile: {target_namespace}")
+    if profile.port is None:
+        raise RuntimeError(f"Existing target namespace has no saved HTTP port: {target_namespace}")
+    if profile.mcp_port is None:
+        raise RuntimeError(f"Existing target namespace has no saved MCP port: {target_namespace}")
+    return BackupLaunchProfile(
+        namespace=target_namespace,
+        port=profile.port,
+        https_port=profile.https_port,
+        mcp_port=profile.mcp_port,
+    )
+
+
+def _resolve_same_name_restore_launch_profile(
+    *,
+    backup_path: Path,
+    target_namespace: str,
+    target_exists: bool,
+) -> BackupLaunchProfile:
+    if target_exists:
+        return _required_existing_target_launch_profile(
+            target_namespace=target_namespace,
+        )
+    restored_profile = read_backup_launch_profile(
+        backup_path,
+        expected_namespace=target_namespace,
+    )
+    suggested_profile = _suggest_import_launch_profile(
+        target_namespace=target_namespace,
+        restored_profile=restored_profile,
+    )
+    return BackupLaunchProfile(
+        namespace=target_namespace,
+        port=suggested_profile.port,
+        https_port=suggested_profile.https_port,
+        mcp_port=suggested_profile.mcp_port,
+    )
+
+
 def _backup_profile_from_request(
     *,
     namespace: str,
@@ -725,6 +769,27 @@ def _assert_import_profile_has_no_internal_overlap(*, profile: BackupLaunchProfi
         )
 
 
+def _restore_import_to_target(
+    *,
+    backup_path: Path,
+    target_database_path: Path,
+    backup_namespace: str,
+    target_namespace: str,
+    launch_profile: BackupLaunchProfile,
+) -> None:
+    restore_backup_to_paths_from_namespace(
+        backup_path,
+        target_database_path,
+        source_namespace=backup_namespace,
+    )
+    save_namespace_launch_profile(
+        namespace=target_namespace,
+        port=launch_profile.port,
+        https_port=launch_profile.https_port,
+        mcp_port=launch_profile.mcp_port,
+    )
+
+
 @router.get("/settings", response_model=BackupSettingsResponse)
 def get_backup_settings(token: Annotated[str, Depends(_require_auth)]):
     settings = load_backup_settings(token=token)
@@ -878,13 +943,21 @@ def restore_backup_preflight(
         backup_path,
         expected_namespace=backup_namespace,
     )
+    target_exists = _restore_target_exists(target_namespace=target_namespace)
     suggested_profile = None
     port_conflicts: list[str] = []
-    if target_namespace != backup_namespace:
-        port_conflicts = _collect_import_profile_port_conflicts(
+    if target_exists:
+        target_profile = _required_existing_target_launch_profile(
             target_namespace=target_namespace,
-            launch_profile=restored_profile,
         )
+        suggested_profile = _response_profile_from_backup_profile(profile=target_profile)
+        assert suggested_profile is not None
+    else:
+        if restored_profile is not None:
+            port_conflicts = _collect_import_profile_port_conflicts(
+                target_namespace=target_namespace,
+                launch_profile=restored_profile,
+            )
         suggested_profile = _suggest_import_launch_profile(
             target_namespace=target_namespace,
             restored_profile=restored_profile,
@@ -894,7 +967,8 @@ def restore_backup_preflight(
         backup_namespace=backup_namespace,
         target_namespace=target_namespace,
         same_namespace=target_namespace == backup_namespace,
-        target_exists=_restore_target_exists(target_namespace=target_namespace),
+        target_is_active=target_namespace == ACTIVE_NAMESPACE,
+        target_exists=target_exists,
         target_requires_password=_target_namespace_requires_password(target_namespace=target_namespace),
         restored_profile=_response_profile_from_backup_profile(profile=restored_profile),
         suggested_profile=suggested_profile,
@@ -935,10 +1009,22 @@ def restore_backup(
     backup_path = folder_directory / folder_filename
     if not backup_path.exists():
         raise HTTPException(status_code=404, detail=f"Backup not found: {folder_filename}")
+    target_exists = _restore_target_exists(target_namespace=target_namespace)
+    launch_profile = _resolve_same_name_restore_launch_profile(
+        backup_path=backup_path,
+        target_namespace=target_namespace,
+        target_exists=target_exists,
+    )
     if target_namespace == ACTIVE_NAMESPACE:
         maintenance_service.enter_maintenance("Restoring backup")
         try:
             restore_backup_to_paths(backup_path, target_database_path)
+            save_namespace_launch_profile(
+                namespace=target_namespace,
+                port=launch_profile.port,
+                https_port=launch_profile.https_port,
+                mcp_port=launch_profile.mcp_port,
+            )
             _reset_runtime_state_after_restore()
         finally:
             maintenance_service.exit_maintenance()
@@ -947,6 +1033,12 @@ def restore_backup(
         open_namespace_suggested = False
     else:
         restore_backup_to_paths(backup_path, target_database_path)
+        save_namespace_launch_profile(
+            namespace=target_namespace,
+            port=launch_profile.port,
+            https_port=launch_profile.https_port,
+            mcp_port=launch_profile.mcp_port,
+        )
     return BackupRestoreResponse(
         backup_id=payload.backup_id,
         source=payload.source,
@@ -999,27 +1091,44 @@ def import_backup(
     if not backup_path.exists():
         raise HTTPException(status_code=404, detail=f"Backup not found: {folder_filename}")
 
-    launch_profile = _backup_profile_from_request(
-        namespace=target_namespace,
-        profile=payload.launch_profile,
-    )
-    _assert_import_profile_has_no_internal_overlap(profile=launch_profile)
-    _assert_import_profile_ports_do_not_conflict(
-        target_namespace=target_namespace,
-        launch_profile=launch_profile,
-    )
+    if target_exists:
+        launch_profile = _required_existing_target_launch_profile(
+            target_namespace=target_namespace,
+        )
+    else:
+        launch_profile = _backup_profile_from_request(
+            namespace=target_namespace,
+            profile=payload.launch_profile,
+        )
+        _assert_import_profile_has_no_internal_overlap(profile=launch_profile)
+        _assert_import_profile_ports_do_not_conflict(
+            target_namespace=target_namespace,
+            launch_profile=launch_profile,
+        )
 
-    restore_backup_to_paths_from_namespace(
-        backup_path,
-        target_database_path,
-        source_namespace=backup_namespace,
-    )
-    save_namespace_launch_profile(
-        namespace=target_namespace,
-        port=launch_profile.port,
-        https_port=launch_profile.https_port,
-        mcp_port=launch_profile.mcp_port,
-    )
+    target_is_active = target_namespace == ACTIVE_NAMESPACE
+    if target_is_active:
+        maintenance_service.enter_maintenance("Importing backup")
+        try:
+            _restore_import_to_target(
+                backup_path=backup_path,
+                target_database_path=target_database_path,
+                backup_namespace=backup_namespace,
+                target_namespace=target_namespace,
+                launch_profile=launch_profile,
+            )
+            _reset_runtime_state_after_restore()
+        finally:
+            maintenance_service.exit_maintenance()
+        _schedule_server_restart_after_restore(delay_seconds=0.5)
+    else:
+        _restore_import_to_target(
+            backup_path=backup_path,
+            target_database_path=target_database_path,
+            backup_namespace=backup_namespace,
+            target_namespace=target_namespace,
+            launch_profile=launch_profile,
+        )
 
     return BackupRestoreResponse(
         backup_id=payload.backup_id,
@@ -1027,7 +1136,7 @@ def import_backup(
         backup_filename=payload.backup_filename,
         backup_namespace=backup_namespace,
         target_namespace=target_namespace,
-        active_namespace_restarted=False,
-        open_namespace_suggested=True,
+        active_namespace_restarted=target_is_active,
+        open_namespace_suggested=not target_is_active,
         message="Backup imported successfully",
     )

{metalist-0.3.4 → metalist-0.3.7}/app/main.py

@@ -34,8 +34,10 @@ from app.security.encryption import set_encryption_required
 from app.server_runtime import resolve_mcp_agent_public_origin
 from app.server_runtime import resolve_https_redirect_url
 from app.server_runtime import resolve_request_host_for_https_redirect
+from app.server_runtime import validate_namespace
 from app.services.exception_capture import CapturedExceptionContext
 from app.services.namespace_deletion_jobs import load_namespace_deletion_job
+from app.services.namespace_rename_jobs import load_namespace_rename_job
 from app.services.namespace_switcher import build_namespace_catalog
 from app.services.namespace_switcher import open_or_launch_namespace
 from app.services.diagnostics import configure_process_diagnostics
@@ -435,36 +437,17 @@ async def maintenance_page(request: Request):
     )
 
 
-def _build_namespace_deleted_links(*, job_id: str, deleted_namespace: str) -> list[dict[str, str]]:
-    catalog = build_namespace_catalog(
-        environ=os.environ,
-        current_namespace=ACTIVE_NAMESPACE,
-    )
-    raw_namespaces = catalog["namespaces"]
-    if not isinstance(raw_namespaces, list):
-        raise RuntimeError("Namespace catalog missing namespaces")
-    links: list[dict[str, str]] = []
-    for entry in raw_namespaces:
-        if not isinstance(entry, dict):
-            raise RuntimeError("Namespace catalog entry must be an object")
-        namespace = entry["namespace"]
-        if not isinstance(namespace, str) or namespace == "":
-            raise RuntimeError("Namespace catalog entry missing namespace")
-        if namespace == deleted_namespace:
-            continue
-        query = urlencode({"job": job_id, "namespace": namespace})
-        link_meta = "Open namespace"
-        if namespace == ACTIVE_NAMESPACE:
-            link_meta = "Already running"
-        links.append(
-            {
-                "namespace": namespace,
-                "label": namespace,
-                "meta": link_meta,
-                "href": f"/namespace-deleted/open?{query}",
-            }
-        )
-    return links
+def _build_namespace_deleted_links(*, job_id: str, redirect_namespace: str) -> list[dict[str, str]]:
+    normalized_redirect_namespace = validate_namespace(namespace=redirect_namespace)
+    query = urlencode({"job": job_id, "namespace": normalized_redirect_namespace})
+    return [
+        {
+            "namespace": normalized_redirect_namespace,
+            "label": normalized_redirect_namespace,
+            "meta": "Selected destination",
+            "href": f"/namespace-deleted/open?{query}",
+        }
+    ]
 
 
 def _resolve_catalog_profile(*, namespace: str) -> tuple[int, int | None, int]:
@@ -543,7 +526,7 @@ async def namespace_deleted_page(request: Request):
     template = templates.get_template("namespace_deleted.html")
     namespace_links = _build_namespace_deleted_links(
         job_id=job_record["job_id"],
-        deleted_namespace=job_record["deleted_namespace"],
+        redirect_namespace=job_record["redirect_namespace"],
     )
     page_state = json.dumps(
         {
@@ -551,6 +534,7 @@ async def namespace_deleted_page(request: Request):
             "deletedNamespace": job_record["deleted_namespace"],
             "initialStatus": job_record["status"],
             "initialError": job_record["error"],
+            "redirectNamespace": job_record["redirect_namespace"],
         }
     )
     return template.render(
@@ -588,7 +572,10 @@ async def namespace_deleted_open_page(request: Request):
         return HTMLResponse(f"Namespace deletion job not found: {job_id}", status_code=404)
     if job_record["status"] == "pending":
         return HTMLResponse("Namespace deletion is still in progress", status_code=409)
-    if namespace == job_record["deleted_namespace"]:
+    if (
+        namespace == job_record["deleted_namespace"]
+        and namespace != job_record["redirect_namespace"]
+    ):
         return HTMLResponse("Deleted namespace is unavailable", status_code=400)
 
     launch_capture = CapturedExceptionContext(
@@ -618,6 +605,75 @@ async def namespace_deleted_open_page(request: Request):
     return response
 
 
+@app.get("/namespace-renamed", response_class=HTMLResponse)
+async def namespace_renamed_page(request: Request):
+    job_id = request.query_params.get("job")
+    if not isinstance(job_id, str) or job_id.strip() == "":
+        return HTMLResponse("Missing namespace rename job", status_code=400)
+    job_record_capture = CapturedExceptionContext(
+        RuntimeError,
+        TypeError,
+        ValueError,
+        FileNotFoundError,
+    )
+    job_record: dict[str, object] | None = None
+    with job_record_capture:
+        job_record = load_namespace_rename_job(job_id=job_id)
+    if job_record_capture.captured_exception is not None:
+        exc = job_record_capture.captured_exception
+        return HTMLResponse(str(exc), status_code=400)
+    if job_record is None:
+        return HTMLResponse(f"Namespace rename job not found: {job_id}", status_code=404)
+
+    page_state = json.dumps(
+        {
+            "jobId": job_record["job_id"],
+            "sourceNamespace": job_record["source_namespace"],
+            "targetNamespace": job_record["target_namespace"],
+            "initialStatus": job_record["status"],
+            "initialError": job_record["error"],
+        }
+    )
+    template = templates.get_template("namespace_renamed.html")
+    return template.render(
+        request=request,
+        version=VERSION,
+        asset_version=ASSET_VERSION,
+        page_title="MetaList - Namespace Renamed",
+        source_namespace=job_record["source_namespace"],
+        target_namespace=job_record["target_namespace"],
+        page_state_json=page_state,
+    )
+
+
+@app.get("/namespace-renamed/open")
+async def namespace_renamed_open_page(request: Request):
+    job_id = request.query_params.get("job")
+    if not isinstance(job_id, str) or job_id.strip() == "":
+        return HTMLResponse("Missing namespace rename job", status_code=400)
+    job_record_capture = CapturedExceptionContext(
+        RuntimeError,
+        TypeError,
+        ValueError,
+        FileNotFoundError,
+    )
+    job_record: dict[str, object] | None = None
+    with job_record_capture:
+        job_record = load_namespace_rename_job(job_id=job_id)
+    if job_record_capture.captured_exception is not None:
+        exc = job_record_capture.captured_exception
+        return HTMLResponse(str(exc), status_code=400)
+    if job_record is None:
+        return HTMLResponse(f"Namespace rename job not found: {job_id}", status_code=404)
+    if job_record["status"] != "succeeded":
+        return HTMLResponse("Namespace rename is not complete", status_code=409)
+    if ACTIVE_NAMESPACE != job_record["target_namespace"]:
+        return HTMLResponse("Renamed namespace is not running here", status_code=409)
+    response = RedirectResponse(url="/?force_reauth=1", status_code=307)
+    clear_auth_cookie(response=response)
+    return response
+
+
 @app.get("/locked", response_class=HTMLResponse)
 async def locked_page(request: Request, db: Annotated[SafeSession, Depends(get_db)]):
     """Render a dedicated locked screen when a session is invalidated."""

{metalist-0.3.4 → metalist-0.3.7}/app/server_runtime.py

@@ -32,6 +32,7 @@ _DEFAULT_KEY_PATH = _DEFAULT_DATABASE_DIRECTORY / "certs" / "metalist-key.pem"
 _DEFAULT_RUNTIME_DIRECTORY = Path(tempfile.gettempdir()) / "metalist-runtime"
 _DEFAULT_NAMESPACES_DIRECTORY_NAME = "namespaces"
 _DEFAULT_NAMESPACE_DELETE_JOBS_DIRECTORY_NAME = "namespace-delete-jobs"
+_DEFAULT_NAMESPACE_RENAME_JOBS_DIRECTORY_NAME = "namespace-rename-jobs"
 _DEFAULT_LOGS_DIRECTORY_NAME = "logs"
 _DEFAULT_NAMESPACE = "default"
 _DEFAULT_HTTP_PORT = 8000
@@ -126,6 +127,10 @@ def resolve_namespace_delete_jobs_directory() -> Path:
     return _DEFAULT_RUNTIME_DIRECTORY / _DEFAULT_NAMESPACE_DELETE_JOBS_DIRECTORY_NAME
 
 
+def resolve_namespace_rename_jobs_directory() -> Path:
+    return _DEFAULT_RUNTIME_DIRECTORY / _DEFAULT_NAMESPACE_RENAME_JOBS_DIRECTORY_NAME
+
+
 def resolve_runtime_logs_directory() -> Path:
     return _DEFAULT_DATABASE_DIRECTORY / _DEFAULT_LOGS_DIRECTORY_NAME