fix(cli): address auto-update follow-ups and include formatting cleanups

Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/cli/auto_update.py

@@ -70,7 +70,7 @@ def detect_install_source(executable: str | None = None) -> InstallSource:
         return InstallSource.HOMEBREW
     if "uv/tools/basic-memory" in normalized:
         return InstallSource.UV_TOOL
-    if "/uv/archive-" in normalized or "/uv/archive-v" in normalized:
+    if "/uv/archive-" in normalized:
         return InstallSource.UVX
     return InstallSource.UNKNOWN
 
@@ -94,39 +94,18 @@ def _run_subprocess(
     capture_output: bool,
 ) -> subprocess.CompletedProcess[str]:
     """Run a subprocess with explicit stdio behavior for protocol safety."""
-    # Trigger: caller needs command output for decision-making (e.g., brew outdated).
-    # Why: update-availability checks parse command output.
-    # Outcome: stdout/stderr are captured in-memory (never forwarded to terminal).
-    if capture_output:
-        return subprocess.run(
-            command,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=timeout_seconds,
-            check=False,
-        )
-
-    if silent:
-        # Trigger: silent operation (MCP/background) with no need for subprocess output.
-        # Why: prevent protocol/terminal pollution from child process output.
-        # Outcome: stdout/stderr are discarded.
-        return subprocess.run(
-            command,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            text=True,
-            timeout=timeout_seconds,
-            check=False,
-        )
+    # Trigger: silent operation (MCP/background) with no need for subprocess output.
+    # Why: prevent protocol/terminal pollution from child process output.
+    # Outcome: stdout/stderr are discarded unless explicit capture is requested.
+    use_devnull = silent and not capture_output
+    stdout_target = subprocess.DEVNULL if use_devnull else subprocess.PIPE
+    stderr_target = subprocess.DEVNULL if use_devnull else subprocess.PIPE
 
     return subprocess.run(
         command,
         stdin=subprocess.DEVNULL,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
+        stdout=stdout_target,
+        stderr=stderr_target,
         text=True,
         timeout=timeout_seconds,
         check=False,
@@ -240,7 +219,7 @@ def run_auto_update(
             # Trigger: mixed naive/aware datetimes from manual config edits.
             # Why: datetime subtraction fails for mixed tz-awareness.
             # Outcome: ignore the gate once and continue with a forced check path.
-            logger.warning("Auto-update interval gate skipped due incompatible timestamp format")
+            logger.warning("Auto-update interval gate skipped due to incompatible timestamp format")
         else:
             if elapsed < timedelta(seconds=config.update_check_interval):
                 return AutoUpdateResult(
@@ -349,6 +328,7 @@ def run_auto_update(
     except (
         RuntimeError,
         urllib.error.URLError,
+        ValueError,
         TimeoutError,
         subprocess.SubprocessError,
         OSError,

src/basic_memory/cli/commands/mcp.py

@@ -91,7 +91,12 @@ def _run_background_auto_update() -> None:
         elif result.status == AutoUpdateStatus.FAILED and result.error:
             logger.warning(f"MCP background auto-update failed: {result.error}")
 
-    threading.Thread(target=_run_background_auto_update, daemon=True).start()
+    # Trigger: stdio transport corresponds to local user installs.
+    # Why: server transports (HTTP/SSE) run in managed environments where
+    # package-manager self-upgrades are inappropriate.
+    # Outcome: background auto-update runs only for local stdio MCP sessions.
+    if transport == "stdio":
+        threading.Thread(target=_run_background_auto_update, daemon=True).start()
 
     # Run the MCP server (blocks)
     # Lifespan handles: initialization, migrations, file sync, cleanup

src/basic_memory/cli/commands/project.py

@@ -227,9 +227,7 @@ async def _list_projects(ws: str | None = None):
 
         console.print(table)
         if cloud_error is not None:
-            console.print(
-                f"[yellow]Cloud project discovery failed: {cloud_error}[/yellow]"
-            )
+            console.print(f"[yellow]Cloud project discovery failed: {cloud_error}[/yellow]")
             console.print(
                 "[dim]Showing local projects only. "
                 "Run 'bm cloud login' or 'bm cloud api-key save <key>' if this is a credentials issue.[/dim]"

tests/api/v2/test_schema_router.py

@@ -668,7 +668,8 @@ async def test_validate_reads_schema_from_file_not_database(
 
     # Overwrite the file on disk with validation=strict
     file_path = Path(file_service.base_path) / schema_entity.file_path
-    file_path.write_text(dedent("""\
+    file_path.write_text(
+        dedent("""\
         ---
         title: Editable Schema
         permalink: schemas/editable-schema
@@ -685,7 +686,8 @@ async def test_validate_reads_schema_from_file_not_database(
 
         ## Observations
         - [note] Schema that will be edited on disk
-    """))
+    """)
+    )
 
     # Create a note missing "role" — strict mode should produce errors, not warnings
     note_entity, _ = await entity_service.create_or_update_entity(
@@ -749,7 +751,8 @@ async def test_validate_falls_back_to_db_on_incomplete_frontmatter(
 
     # Overwrite file with frontmatter missing the 'schema' key
     file_path = Path(file_service.base_path) / schema_entity.file_path
-    file_path.write_text(dedent("""\
+    file_path.write_text(
+        dedent("""\
         ---
         title: Incomplete Schema
         permalink: schemas/incomplete-schema
@@ -761,7 +764,8 @@ async def test_validate_falls_back_to_db_on_incomplete_frontmatter(
 
         ## Observations
         - [note] Mid-edit state
-    """))
+    """)
+    )
 
     # Create a note to validate against this schema
     note_entity, _ = await entity_service.create_or_update_entity(

tests/cli/test_auto_update.py

@@ -9,8 +9,10 @@
 from rich.console import Console
 
 from basic_memory.cli.auto_update import (
+    AutoUpdateResult,
     AutoUpdateStatus,
     InstallSource,
+    _is_interactive_session,
     detect_install_source,
     maybe_run_periodic_auto_update,
     run_auto_update,
@@ -43,6 +45,25 @@ def _base_config(tmp_path) -> BasicMemoryConfig:
     return BasicMemoryConfig(projects={"main": {"path": str(tmp_path / "main")}})
 
 
+def _result(
+    status: AutoUpdateStatus,
+    *,
+    message: str | None,
+    error: str | None = None,
+) -> AutoUpdateResult:
+    return AutoUpdateResult(
+        status=status,
+        source=InstallSource.UV_TOOL,
+        checked=True,
+        update_available=status in {AutoUpdateStatus.UPDATE_AVAILABLE, AutoUpdateStatus.UPDATED},
+        updated=status == AutoUpdateStatus.UPDATED,
+        latest_version="9.9.9",
+        message=message,
+        error=error,
+        restart_recommended=status == AutoUpdateStatus.UPDATED,
+    )
+
+
 def test_detect_install_source_variants():
     assert (
         detect_install_source("/opt/homebrew/Cellar/basic-memory/0.18.0/bin/python")
@@ -271,3 +292,83 @@ def test_maybe_run_periodic_auto_update_non_interactive_has_no_console_output():
     )
     assert result is None
     assert buf.getvalue() == ""
+
+
+def test_maybe_run_periodic_auto_update_prints_updated(monkeypatch):
+    console, buf = _capture_console()
+    monkeypatch.setattr(
+        "basic_memory.cli.auto_update.run_auto_update",
+        lambda **kwargs: _result(
+            AutoUpdateStatus.UPDATED,
+            message="Basic Memory was updated successfully.",
+        ),
+    )
+
+    result = maybe_run_periodic_auto_update("status", is_interactive=True, console=console)
+    assert result is not None
+    assert result.status == AutoUpdateStatus.UPDATED
+    assert "updated successfully" in buf.getvalue().lower()
+
+
+def test_maybe_run_periodic_auto_update_prints_available(monkeypatch):
+    console, buf = _capture_console()
+    monkeypatch.setattr(
+        "basic_memory.cli.auto_update.run_auto_update",
+        lambda **kwargs: _result(
+            AutoUpdateStatus.UPDATE_AVAILABLE,
+            message="Update available (latest: 9.9.9).",
+        ),
+    )
+
+    result = maybe_run_periodic_auto_update("status", is_interactive=True, console=console)
+    assert result is not None
+    assert result.status == AutoUpdateStatus.UPDATE_AVAILABLE
+    assert "update available" in buf.getvalue().lower()
+
+
+def test_maybe_run_periodic_auto_update_prints_failed_with_error(monkeypatch):
+    console, buf = _capture_console()
+    monkeypatch.setattr(
+        "basic_memory.cli.auto_update.run_auto_update",
+        lambda **kwargs: _result(
+            AutoUpdateStatus.FAILED,
+            message="Automatic update check failed.",
+            error="network timeout",
+        ),
+    )
+
+    result = maybe_run_periodic_auto_update("status", is_interactive=True, console=console)
+    assert result is not None
+    assert result.status == AutoUpdateStatus.FAILED
+    output = buf.getvalue().lower()
+    assert "automatic update check failed" in output
+    assert "network timeout" in output
+
+
+def test_maybe_run_periodic_auto_update_uses_interactive_probe_when_not_overridden(monkeypatch):
+    console, buf = _capture_console()
+    monkeypatch.setattr("basic_memory.cli.auto_update._is_interactive_session", lambda: True)
+    monkeypatch.setattr(
+        "basic_memory.cli.auto_update.run_auto_update",
+        lambda **kwargs: _result(
+            AutoUpdateStatus.UP_TO_DATE,
+            message="Basic Memory is up to date.",
+        ),
+    )
+
+    result = maybe_run_periodic_auto_update("status", console=console)
+    assert result is not None
+    assert result.status == AutoUpdateStatus.UP_TO_DATE
+    # UP_TO_DATE is intentionally silent for periodic checks.
+    assert buf.getvalue() == ""
+
+
+def test_is_interactive_session_handles_closed_stdio(monkeypatch):
+    class _BrokenStream:
+        def isatty(self) -> bool:
+            raise ValueError("I/O operation on closed file")
+
+    monkeypatch.setattr("basic_memory.cli.auto_update.sys.stdin", _BrokenStream())
+    monkeypatch.setattr("basic_memory.cli.auto_update.sys.stdout", _BrokenStream())
+
+    assert _is_interactive_session() is False

tests/cli/test_cloud_status.py

@@ -63,9 +63,7 @@ def is_token_valid(self, t):
     monkeypatch.setattr(
         "basic_memory.cli.commands.cloud.core_commands.ConfigManager", FakeConfigManager
     )
-    monkeypatch.setattr(
-        "basic_memory.cli.commands.cloud.core_commands.CLIAuth", FakeAuth
-    )
+    monkeypatch.setattr("basic_memory.cli.commands.cloud.core_commands.CLIAuth", FakeAuth)
     monkeypatch.setattr(
         "basic_memory.cli.commands.cloud.core_commands.get_cloud_config",
         lambda: ("cid", "domain", "https://cloud.example.com"),