MetaList 0.3.3__tar.gz → 0.3.6__tar.gz

{metalist-0.3.3/metalist.egg-info → metalist-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.3.3
+Version: 0.3.6
 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.3`.
+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.3 → metalist-0.3.6}/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.3`.
+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.3 → metalist-0.3.6}/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
@@ -88,6 +89,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 +439,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:

{metalist-0.3.3 → metalist-0.3.6}/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,22 @@ 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 _backup_profile_from_request(
     *,
     namespace: str,
@@ -725,6 +743,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,23 +917,32 @@ 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(
-            target_namespace=target_namespace,
-            launch_profile=restored_profile,
-        )
-        suggested_profile = _suggest_import_launch_profile(
-            target_namespace=target_namespace,
-            restored_profile=restored_profile,
-        )
+        if target_exists:
+            target_profile = _required_existing_target_launch_profile(
+                target_namespace=target_namespace,
+            )
+            suggested_profile = _response_profile_from_backup_profile(profile=target_profile)
+            assert suggested_profile is not None
+        else:
+            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,
+            )
 
     return BackupRestorePreflightResponse(
         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,
@@ -999,27 +1047,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 +1092,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.3 → metalist-0.3.6}/app/services/namespace_deletion_worker.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import signal
 import subprocess
+import sys
 import time
 import traceback
 
@@ -14,6 +15,8 @@ from app.server_runtime import validate_namespace
 from app.services.exception_capture import CapturedExceptionContext
 from app.services.namespace_deletion_jobs import mark_namespace_deletion_job_failed
 from app.services.namespace_deletion_jobs import mark_namespace_deletion_job_succeeded
+from app.services.windows_process_control import is_process_running as is_windows_process_running
+from app.services.windows_process_control import stop_process as stop_windows_process
 
 
 _WAIT_POLL_INTERVAL_SECONDS = 0.25
@@ -50,6 +53,8 @@ def _is_process_running(*, pid: int) -> bool:
         raise TypeError(f"pid must be an int, got {type(pid)}")
     if pid <= 0:
         raise ValueError(f"pid must be positive, got: {pid}")
+    if sys.platform == "win32":
+        return is_windows_process_running(pid=pid)
     kill_capture = CapturedExceptionContext(ProcessLookupError, PermissionError)
     with kill_capture:
         os.kill(pid, 0)
@@ -92,6 +97,9 @@ def _send_signal_if_running(*, pid: int, signal_number: int) -> None:
 
 
 def _stop_process(*, pid: int) -> None:
+    if sys.platform == "win32":
+        stop_windows_process(pid=pid)
+        return
     if _wait_for_process_exit(pid=pid, timeout_seconds=_INITIAL_EXIT_GRACE_SECONDS):
         return
 

{metalist-0.3.3 → metalist-0.3.6}/app/services/namespace_switcher.py

@@ -30,6 +30,9 @@ from app.server_runtime import validate_namespace
 from app.services.diagnostics import recycle_direct_append_log_file
 from app.services.exception_capture import CapturedExceptionContext
 from app.services.namespace_deletion_jobs import create_namespace_deletion_job
+from app.services.windows_process_control import find_listening_pids_for_port as find_windows_listening_pids_for_port
+from app.services.windows_process_control import is_process_running as is_windows_process_running
+from app.services.windows_process_control import stop_process as stop_windows_process
 
 
 _PROJECT_ROOT = Path(__file__).resolve().parents[2]
@@ -1086,6 +1089,8 @@ def _is_process_running(*, pid: int) -> bool:
         raise TypeError(f"pid must be an int, got {type(pid)}")
     if pid <= 0:
         raise ValueError(f"pid must be positive, got: {pid}")
+    if sys.platform == "win32":
+        return is_windows_process_running(pid=pid)
     kill_capture = CapturedExceptionContext(ProcessLookupError, PermissionError)
     with kill_capture:
         os.kill(pid, 0)
@@ -1128,6 +1133,9 @@ def _send_signal_if_running(*, pid: int, signal_number: int) -> None:
 
 
 def _stop_process(*, pid: int) -> None:
+    if sys.platform == "win32":
+        stop_windows_process(pid=pid)
+        return
     if not _is_process_running(pid=pid):
         return
 
@@ -1147,6 +1155,8 @@ def _find_listening_pids_for_port(*, port: int) -> list[int]:
         raise TypeError(f"port must be an int, got {type(port)}")
     if port <= 0 or port > 65535:
         raise ValueError(f"port must be between 1 and 65535, got: {port}")
+    if sys.platform == "win32":
+        return find_windows_listening_pids_for_port(port=port)
 
     lsof_path = shutil.which("lsof")
     if lsof_path is None:

metalist-0.3.6/app/services/windows_process_control.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import time
+
+
+_WAIT_POLL_INTERVAL_SECONDS = 0.25
+_TERMINATE_GRACE_SECONDS = 5.0
+_KILL_GRACE_SECONDS = 5.0
+
+
+def _validate_pid(*, pid: int) -> None:
+    if not isinstance(pid, int):
+        raise TypeError(f"pid must be an int, got {type(pid)}")
+    if pid <= 0:
+        raise ValueError(f"pid must be positive, got: {pid}")
+
+
+def _validate_port(*, port: int) -> None:
+    if not isinstance(port, int):
+        raise TypeError(f"port must be an int, got {type(port)}")
+    if port <= 0 or port > 65535:
+        raise ValueError(f"port must be between 1 and 65535, got: {port}")
+
+
+def _resolve_powershell_path() -> str:
+    powershell_path = shutil.which("powershell.exe")
+    if powershell_path is not None:
+        return powershell_path
+    pwsh_path = shutil.which("pwsh.exe")
+    if pwsh_path is not None:
+        return pwsh_path
+    raise RuntimeError("PowerShell is required for MetaList process management on Windows")
+
+
+def _run_powershell(*, script: str, operation: str) -> str:
+    if script.strip() == "":
+        raise ValueError("PowerShell script must not be empty")
+    if operation.strip() == "":
+        raise ValueError("PowerShell operation must not be empty")
+    completed = subprocess.run(
+        [
+            _resolve_powershell_path(),
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            script,
+        ],
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise RuntimeError(
+            f"PowerShell failed while {operation}: "
+            f"exit={completed.returncode} stderr={completed.stderr.strip()!r}"
+        )
+    return completed.stdout.strip()
+
+
+def find_listening_pids_for_port(*, port: int) -> list[int]:
+    _validate_port(port=port)
+    stdout = _run_powershell(
+        script=(
+            f"@(Get-NetTCPConnection -State Listen -LocalPort {port} -ErrorAction SilentlyContinue "
+            "| Select-Object -ExpandProperty OwningProcess) -join [Environment]::NewLine"
+        ),
+        operation=f"checking port {port}",
+    )
+    if stdout == "":
+        return []
+
+    ordered_pids: list[int] = []
+    seen_pids: set[int] = set()
+    for raw_line in stdout.splitlines():
+        raw_pid = raw_line.strip()
+        if not raw_pid.isdigit():
+            raise RuntimeError(
+                f"PowerShell returned a non-numeric listener pid for port {port}: {raw_pid!r}"
+            )
+        pid = int(raw_pid)
+        if pid <= 0:
+            raise RuntimeError(f"PowerShell returned invalid listener pid for port {port}: {pid}")
+        if pid in seen_pids:
+            continue
+        seen_pids.add(pid)
+        ordered_pids.append(pid)
+    return ordered_pids
+
+
+def is_process_running(*, pid: int) -> bool:
+    _validate_pid(pid=pid)
+    stdout = _run_powershell(
+        script=(
+            f"@(Get-Process -Id {pid} -ErrorAction SilentlyContinue "
+            "| Select-Object -ExpandProperty Id) -join [Environment]::NewLine"
+        ),
+        operation=f"checking process {pid}",
+    )
+    if stdout == "":
+        return False
+    if stdout != str(pid):
+        raise RuntimeError(f"PowerShell returned an unexpected process id for pid {pid}: {stdout!r}")
+    return True
+
+
+def _wait_for_process_exit(*, pid: int, timeout_seconds: float) -> bool:
+    if not isinstance(timeout_seconds, float):
+        raise TypeError(f"timeout_seconds must be a float, got {type(timeout_seconds)}")
+    if timeout_seconds < 0.0:
+        raise ValueError(f"timeout_seconds must be >= 0.0, got {timeout_seconds}")
+
+    deadline = time.monotonic() + timeout_seconds
+    while time.monotonic() < deadline:
+        if not is_process_running(pid=pid):
+            return True
+        time.sleep(_WAIT_POLL_INTERVAL_SECONDS)
+    return not is_process_running(pid=pid)
+
+
+def stop_process(*, pid: int) -> None:
+    _validate_pid(pid=pid)
+    if not is_process_running(pid=pid):
+        return
+
+    _run_powershell(
+        script=f"Stop-Process -Id {pid} -ErrorAction Stop",
+        operation=f"stopping process {pid}",
+    )
+    if _wait_for_process_exit(pid=pid, timeout_seconds=_TERMINATE_GRACE_SECONDS):
+        return
+    if not is_process_running(pid=pid):
+        return
+
+    _run_powershell(
+        script=f"Stop-Process -Id {pid} -Force -ErrorAction Stop",
+        operation=f"force-stopping process {pid}",
+    )
+    if _wait_for_process_exit(pid=pid, timeout_seconds=_KILL_GRACE_SECONDS):
+        return
+    if not is_process_running(pid=pid):
+        return
+    raise RuntimeError(f"Timed out waiting for Windows process {pid} to exit")

{metalist-0.3.3 → metalist-0.3.6}/app/static/css/main.css

@@ -1472,19 +1472,6 @@ body.ontology-modal-open #ontology-modal {
     font-weight: 700;
 }
 
-.backup-restore-port-config {
-    margin: 16px 0;
-}
-
-.backup-restore-port-config h4 {
-    margin: 0 0 8px;
-}
-
-.backup-restore-port-config ul {
-    margin: 8px 0 0;
-    padding-left: 22px;
-}
-
 .backup-retention-modal-content {
     width: min(760px, 92vw);
 }

{metalist-0.3.3 → metalist-0.3.6}/app/static/js/modules/auth.js

@@ -533,7 +533,13 @@ export const Auth = {
                 if (typeof status.error === 'string' && status.error.length > 0) {
                     throw new Error(status.error);
                 }
-                throw new Error('Hydration failed');
+                const failedPhase = typeof status.phase === 'string' && status.phase.length > 0
+                    ? status.phase
+                    : 'unknown phase';
+                const failedMessage = typeof status.message === 'string' && status.message.length > 0
+                    ? status.message
+                    : 'server returned no error detail';
+                throw new Error(`Hydration failed during ${failedPhase}: ${failedMessage}`);
             }
             await new Promise((resolve) => setTimeout(resolve, 200));
             const pollResponse = await fetch(CONFIG.API.AUTH.HYDRATION_STATUS, { headers });
@@ -680,6 +686,7 @@ export const Auth = {
         }
 
         const responseText = await response.text();
+        let startupPhase = 'reading the login response';
         try {
             const data = JSON.parse(responseText);
 
@@ -691,28 +698,41 @@ export const Auth = {
             if (data.hydration_required !== true) {
                 throw new Error('Login response must require the progress flow');
             }
+            startupPhase = 'hydrating the workspace';
             await this._runHydrationFlow();
 
             console.log('[Auth] Login successful, initializing ModeManager');
             if (window.ModeManager) {
+                startupPhase = 'initializing the workspace UI';
                 await window.ModeManager.init({});
+                startupPhase = 'initializing the command palette';
                 await CommandPalette.init();
+                startupPhase = 'finishing the startup introduction';
                 await this.waitForStartupIntro();
+                startupPhase = 'revealing the workspace';
                 this.revealMainApp();
+                startupPhase = 'starting reminders';
                 await ReminderSurface.start();
                 document.body.dataset.appReady = 'true';
             } else {
+                startupPhase = 'reloading the workspace';
                 window.location.reload();
             }
         } catch (error) {
             document.body.classList.remove('loading');
             this._setLoginLoadingTitle('Workspace startup failed');
             const loadingMessage = this._requireElement('login-loading-message');
-            loadingMessage.textContent = 'Your password was accepted, but the workspace could not finish opening.';
+            const errorMessage = error instanceof Error
+                ? `${error.name}: ${error.message}`
+                : `Non-Error thrown: ${String(error)}`;
+            const diagnosticMessage = `${startupPhase}: ${errorMessage}`;
+            loadingMessage.textContent =
+                `Your password was accepted, but the workspace could not finish opening. ${diagnosticMessage}`;
+            window.alert(`MetaList workspace startup failed:\n\n${diagnosticMessage}`);
             if (error instanceof Error) {
                 throw error;
             }
-            throw new Error('Workspace startup failed');
+            throw new Error(errorMessage);
         }
         document.body.classList.remove('loading');
     },