bazaar-compute-node 0.1.27__tar.gz → 0.1.29__tar.gz

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.27
+Version: 0.1.29
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: cryptography>=45.0.0
+Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: protobug==1.0.0
 Requires-Dist: tzdata>=2024.1 ; sys_platform == 'win32'

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.27"
+version = "0.1.29"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "jinja2>=3.1.6",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.27"
+version = "0.1.29"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -10,6 +10,7 @@ dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
     "cryptography>=45.0.0",
+    "jinja2>=3.1.6",
     "pydantic>=2.0.0",
     "protobug==1.0.0",
     "tzdata>=2024.1; sys_platform == 'win32'",

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/agent.py

@@ -277,6 +277,7 @@ class AgentApplication:
             "channel": self.channel.name,
             "runtime": self.runtime.name,
             "channel_health": dict(self.channel.health),
+            "orchestrator_health": self.orchestrator.health,
         }
 
     async def _cleanup_partial_start(self) -> None:

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/application.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from ..core.concurrency import SessionLockRegistry
-from ..core.lifecycle import TimeoutBudget
+from ..core.lifecycle import ITaskFailureSource, TimeoutBudget
 from ..core.models import InboundAttachment, Message
 from ..core.observability import IAudit
 from ..core.orchestration import ReminderScheduler
@@ -245,7 +245,61 @@ class NodeApplication:
                 loop.add_signal_handler(signum, self._stopped.set)
             except NotImplementedError, RuntimeError:
                 pass
-        await self._stopped.wait()
+        stop_task = asyncio.create_task(self._stopped.wait(), name="bcn-stop-signal")
+        sources: list[tuple[str, ITaskFailureSource]] = [
+            ("timer_wheel", self.timer_wheel),
+            ("reminder_scheduler", self.reminder_scheduler),
+            ("command_server", self.command_server),
+        ]
+        if isinstance(self.storage, ITaskFailureSource):
+            sources.append(("storage", self.storage))
+        failure_tasks = {
+            asyncio.create_task(
+                source.wait_failure(),
+                name=f"bcn-critical-{name}",
+            ): name
+            for name, source in sources
+        }
+        tasks = {stop_task, *failure_tasks}
+        try:
+            done, _ = await asyncio.wait(
+                tasks,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            failure: tuple[str, BaseException] | None = None
+            for task in done:
+                if task is stop_task:
+                    continue
+                try:
+                    task.result()
+                except asyncio.CancelledError:
+                    caught: BaseException = RuntimeError(
+                        f"{failure_tasks[task]} failure monitor stopped unexpectedly"
+                    )
+                except BaseException as error:  # noqa: BLE001
+                    caught = error
+                else:
+                    caught = RuntimeError(
+                        f"{failure_tasks[task]} failure monitor returned unexpectedly"
+                    )
+                if failure is None:
+                    failure = failure_tasks[task], caught
+            if failure is not None:
+                component, error = failure
+                self._ready = False
+                self._accepting = False
+                self._log(
+                    "bcn.critical.failed",
+                    component=component,
+                    error_type=type(error).__name__,
+                    error=_safe_error(error),
+                )
+                raise error
+        finally:
+            for task in tasks:
+                if not task.done():
+                    task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
 
     async def _publish_inbox_wake(
         self,

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/command.py

@@ -21,7 +21,9 @@ from ..core.command import (
     ICommandService,
     InboxListResult,
     MessageSendFreshnessHold,
+    MessageSendSuccess,
     SessionNotFoundError,
+    TargetProjection,
 )
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -62,7 +64,14 @@ def _serialize_attachment(
     }
 
 
-def serialize_message(message: Message) -> dict[str, object]:
+def serialize_message(
+    message: Message,
+    target_projections: tuple[TargetProjection, ...] = (),
+) -> dict[str, object]:
+    targets = {
+        projection.canonical_target: projection.display_target
+        for projection in target_projections
+    }
     return {
         "seq": message.seq,
         "message_id": message.message_id,
@@ -84,13 +93,19 @@ def serialize_message(message: Message) -> dict[str, object]:
             if message.system_message_kind is None
             else message.system_message_kind.value
         ),
-        "system_message_source_target": message.metadata.get(
-            "system_message_source_target"
+        "system_message_source_target": (
+            targets.get(source_target, source_target)
+            if isinstance(
+                source_target := message.metadata.get("system_message_source_target"),
+                str,
+            )
+            else None
         ),
         "system_message_source_message_id": message.metadata.get(
             "system_message_source_message_id"
         ),
         "message_type": message.message_type,
+        "target": targets.get(message.target, message.target),
         "canonical_target": message.target,
         "target_kind": message.target_kind.value,
         "mentions_agent": message.mentions_agent,
@@ -447,10 +462,11 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_message(message) for message in result.messages
+                        serialize_message(message, result.target_projections)
+                        for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_message(message)
+                        serialize_message(message, result.target_projections)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -471,7 +487,7 @@ class CommandDispatcher:
             request = cast(_MessageReadRequest, request)
             result = await self._service.read(
                 session_id,
-                target=request.target,
+                raw_target=request.target,
                 around_message_id=request.around_message_id,
                 limit=request.limit,
             )
@@ -479,10 +495,11 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_message(message) for message in result.messages
+                        serialize_message(message, result.target_projections)
+                        for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_message(message)
+                        serialize_message(message, result.target_projections)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -496,7 +513,7 @@ class CommandDispatcher:
             result = await self._service.send(
                 session_id=session_id,
                 command_id=request.command_id,
-                target=request.target,
+                raw_target=request.target,
                 body=request.body,
                 created_at_ms=request.created_at_ms,
                 attachment_paths=tuple(request.attachment_paths),
@@ -508,22 +525,25 @@ class CommandDispatcher:
                     "ok": True,
                     "result": {"text": format_freshness_hold(result)},
                 }
-            delivery_state = result.delivery_state
+            if not isinstance(result, MessageSendSuccess):
+                raise AssertionError("message send returned an unsupported result")
+            message = result.message
+            delivery_state = message.delivery_state
             if delivery_state is None:
                 raise RuntimeError("outbound message has no delivery state")
             if delivery_state is OutboundDeliveryState.SENT:
                 text = (
-                    f"Message sent to {result.target}. Message ID: {result.message_id}"
+                    f"Message sent to {result.target}. Message ID: {message.message_id}"
                 )
             elif delivery_state is OutboundDeliveryState.QUEUED:
                 text = (
                     f"Message queued to {result.target}. "
-                    f"Message ID: {result.message_id}"
+                    f"Message ID: {message.message_id}"
                 )
             elif delivery_state is OutboundDeliveryState.PARTIAL:
                 raise CommandDispatchError(
                     "SEND_PARTIAL",
-                    result.error_message
+                    message.error_message
                     or "Message delivery was only partially confirmed.",
                     next_action=(
                         "Do not retry the complete message automatically; reconcile "
@@ -533,13 +553,13 @@ class CommandDispatcher:
             elif delivery_state is OutboundDeliveryState.UNKNOWN:
                 raise CommandDispatchError(
                     "SEND_UNKNOWN",
-                    result.error_message or "Message delivery outcome is unknown.",
+                    message.error_message or "Message delivery outcome is unknown.",
                     next_action="Reconcile channel delivery before retrying.",
                 )
             elif delivery_state is OutboundDeliveryState.FAILED:
                 raise CommandDispatchError(
                     "SEND_FAILED",
-                    result.error_message or "Message delivery failed.",
+                    message.error_message or "Message delivery failed.",
                     next_action="Fix the provider error before retrying.",
                 )
             else:
@@ -553,8 +573,14 @@ class CommandDispatcher:
 
         if resource == "thread" and command == "unfollow":
             request = cast(_ThreadUnfollowRequest, request)
-            changed = await self._service.unfollow(session_id, target=request.target)
-            return {"ok": True, "result": {"changed": changed}}
+            result = await self._service.unfollow(
+                session_id,
+                raw_target=request.target,
+            )
+            return {
+                "ok": True,
+                "result": {"target": result.target, "changed": result.changed},
+            }
 
         raise AssertionError("validated command route has no handler")
 
@@ -578,7 +604,7 @@ def _message_timestamp(message: Mapping[str, object]) -> int:
 def _message_header_fields(
     message: Mapping[str, object],
 ) -> tuple[str, str, str, str, str | None, str]:
-    target = cast(str, message["canonical_target"])
+    target = cast(str, message["target"])
     message_id = cast(str, message["message_id"])
     sender_kind = cast(str, message["sender_kind"])
     sender_value = message["sender"]
@@ -694,9 +720,13 @@ def format_read_message(
 
 
 def format_freshness_hold(result: MessageSendFreshnessHold) -> str:
-    messages = [serialize_message(message) for message in result.messages]
+    messages = [
+        serialize_message(message, result.target_projections)
+        for message in result.messages
+    ]
     referenced_messages = [
-        serialize_message(message) for message in result.referenced_messages
+        serialize_message(message, result.target_projections)
+        for message in result.referenced_messages
     ]
     shown = len(messages)
     total = result.newer_message_total

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/system_service.py

@@ -6,7 +6,6 @@ import getpass
 import locale
 import os
 import platform
-import plistlib
 import shlex
 import shutil
 import subprocess
@@ -15,10 +14,10 @@ import tempfile
 import time
 from dataclasses import dataclass
 from pathlib import Path
-from xml.etree import ElementTree
 
 from ..core.paths import resolve_data_dir
 from ..i18n import Translator, create_translator
+from ..rendering import TextTemplate
 from .config import ConfigurationError, load_control_configuration, resolve_config_path
 from .transport import LocalCommandClient, local_endpoint_for_path
 
@@ -26,10 +25,16 @@ SYSTEMD_UNIT_NAME = "bcn.service"
 LAUNCHD_LABEL = "io.github.yuchanns.bazaar-compute-node"
 WINDOWS_TASK_NAME = r"\BazaarComputeNode"
 MANAGED_MARKER = "Managed by bazaar-compute-node."
-TASK_NAMESPACE = "http://schemas.microsoft.com/windows/2004/02/mit/task"
 WINDOWS_STOP_ATTEMPTS = 100
 WINDOWS_STOP_INTERVAL = 0.05
 
+_SYSTEMD_UNIT_TEMPLATE = TextTemplate.from_resource("system_service/systemd.service")
+_LAUNCHD_PLIST_TEMPLATE = TextTemplate.from_resource("system_service/launchd.plist")
+_LAUNCHD_WRAPPER_TEMPLATE = TextTemplate.from_resource("system_service/launchd.sh")
+_WINDOWS_TASK_TEMPLATE = TextTemplate.from_resource("system_service/windows.xml")
+_WINDOWS_LAUNCHER_TEMPLATE = TextTemplate.from_resource("system_service/windows.vbs")
+_WINDOWS_WRAPPER_TEMPLATE = TextTemplate.from_resource("system_service/windows.ps1")
+
 
 @dataclass(frozen=True, slots=True)
 class SystemServiceContext:
@@ -166,109 +171,53 @@ def _powershell_literal(path: Path | str | None) -> str:
 
 
 def _render_systemd_unit(context: SystemServiceContext) -> str:
-    executable = _require_executable(context)
-    lines = [
-        f"# {MANAGED_MARKER}",
-        "[Unit]",
-        "Description=Bazaar Compute Node",
-        "",
-        "[Service]",
-        "Type=simple",
-        f"ExecStart={_systemd_quote(executable)} run --config {_systemd_quote(context.config_path)}",
-        f"WorkingDirectory={_systemd_quote(context.data_dir)}",
-    ]
-    if context.env_file is not None:
-        lines.append(f"EnvironmentFile=-{_systemd_quote(context.env_file)}")
-    lines.extend(
-        (
-            "Restart=on-failure",
-            "RestartSec=5",
-            "KillSignal=SIGTERM",
-            "TimeoutStopSec=15",
-            "UMask=0077",
-            "StandardOutput=journal",
-            "StandardError=journal",
-            "",
-            "[Install]",
-            "WantedBy=default.target",
-            "",
-        )
+    return _SYSTEMD_UNIT_TEMPLATE.render(
+        {
+            "managed_marker": MANAGED_MARKER,
+            "executable": _systemd_quote(_require_executable(context)),
+            "config_path": _systemd_quote(context.config_path),
+            "data_dir": _systemd_quote(context.data_dir),
+            "environment_file": (
+                "" if context.env_file is None else _systemd_quote(context.env_file)
+            ),
+        }
     )
-    return "\n".join(lines)
 
 
 def _render_launchd_wrapper() -> str:
-    return f"""#!/bin/sh
-# {MANAGED_MARKER}
-set -eu
-
-if [ -n "${{BCN_ENV_FILE:-}}" ] && [ -f "$BCN_ENV_FILE" ]; then
-    set -a
-    . "$BCN_ENV_FILE"
-    set +a
-fi
-
-exec "$BCN_EXECUTABLE" run --config "$BCN_CONFIG"
-"""
+    return _LAUNCHD_WRAPPER_TEMPLATE.render({"managed_marker": MANAGED_MARKER})
 
 
 def _render_launchd_plist(
     context: SystemServiceContext,
     wrapper_path: Path,
 ) -> bytes:
-    payload = {
-        "Label": LAUNCHD_LABEL,
-        "Comment": MANAGED_MARKER,
-        "ProgramArguments": [str(wrapper_path)],
-        "WorkingDirectory": str(context.data_dir),
-        "EnvironmentVariables": {
-            "BCN_CONFIG": str(context.config_path),
-            "BCN_ENV_FILE": "" if context.env_file is None else str(context.env_file),
-            "BCN_EXECUTABLE": str(_require_executable(context)),
-        },
-        "RunAtLoad": True,
-        "KeepAlive": True,
-        "ProcessType": "Background",
-        "ThrottleInterval": 5,
-        "StandardOutPath": str(context.log_path),
-        "StandardErrorPath": str(context.log_path),
-    }
-    return plistlib.dumps(payload, fmt=plistlib.FMT_XML, sort_keys=False)
+    return _LAUNCHD_PLIST_TEMPLATE.render(
+        {
+            "label": LAUNCHD_LABEL,
+            "managed_marker": MANAGED_MARKER,
+            "wrapper_path": str(wrapper_path),
+            "data_dir": str(context.data_dir),
+            "config_path": str(context.config_path),
+            "environment_file": (
+                "" if context.env_file is None else str(context.env_file)
+            ),
+            "executable": str(_require_executable(context)),
+            "log_path": str(context.log_path),
+        }
+    ).encode("utf-8")
 
 
 def _render_windows_wrapper(context: SystemServiceContext) -> str:
-    executable = _powershell_literal(_require_executable(context))
-    config_path = _powershell_literal(context.config_path)
-    environment_script = _powershell_literal(context.env_file)
-    log_path = _powershell_literal(context.log_path)
-    return f"""# {MANAGED_MARKER}
-$ErrorActionPreference = 'Stop'
-
-$executable = {executable}
-$configPath = {config_path}
-$environmentScript = {environment_script}
-$logPath = {log_path}
-
-if ($environmentScript -and (Test-Path -LiteralPath $environmentScript)) {{
-    try {{
-        . $environmentScript
-    }} catch {{
-        $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
-        exit 1
-    }}
-}}
-
-# Native stderr is routed to the service log and must not terminate the wrapper.
-$ErrorActionPreference = 'Continue'
-try {{
-    & $executable run --config $configPath *>> $logPath
-    $exitCode = $LASTEXITCODE
-}} catch {{
-    $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
-    exit 1
-}}
-exit $exitCode
-"""
+    return _WINDOWS_WRAPPER_TEMPLATE.render(
+        {
+            "managed_marker": MANAGED_MARKER,
+            "executable": _powershell_literal(_require_executable(context)),
+            "config_path": _powershell_literal(context.config_path),
+            "environment_script": _powershell_literal(context.env_file),
+            "log_path": _powershell_literal(context.log_path),
+        }
+    )
 
 
 def _vbs_literal(value: Path | str) -> str:
@@ -280,80 +229,27 @@ def _render_windows_launcher(wrapper_path: Path) -> str:
         "powershell.exe -NoProfile -NonInteractive -WindowStyle Hidden "
         f'-ExecutionPolicy Bypass -File "{wrapper_path}"'
     )
-    return f"""' {MANAGED_MARKER}
-Option Explicit
-
-Dim shell
-Dim command
-Dim exitCode
-
-Set shell = CreateObject("WScript.Shell")
-command = {command}
-exitCode = shell.Run(command, 0, True)
-WScript.Quit exitCode
-"""
-
-
-def _add_task_element(
-    parent: ElementTree.Element,
-    name: str,
-    text: str | None = None,
-) -> ElementTree.Element:
-    element = ElementTree.SubElement(parent, f"{{{TASK_NAMESPACE}}}{name}")
-    if text is not None:
-        element.text = text
-    return element
+    return _WINDOWS_LAUNCHER_TEMPLATE.render(
+        {
+            "managed_marker": MANAGED_MARKER,
+            "command": command,
+        }
+    )
 
 
 def _render_windows_task(
     context: SystemServiceContext,
     launcher_path: Path,
 ) -> bytes:
-    ElementTree.register_namespace("", TASK_NAMESPACE)
-    task = ElementTree.Element(
-        f"{{{TASK_NAMESPACE}}}Task",
-        {"version": "1.4"},
-    )
-    registration = _add_task_element(task, "RegistrationInfo")
-    _add_task_element(registration, "Author", context.user)
-    _add_task_element(registration, "Description", MANAGED_MARKER)
-    triggers = _add_task_element(task, "Triggers")
-    logon_trigger = _add_task_element(triggers, "LogonTrigger")
-    _add_task_element(logon_trigger, "Enabled", "true")
-    _add_task_element(logon_trigger, "UserId", context.user)
-    principals = _add_task_element(task, "Principals")
-    principal = ElementTree.SubElement(
-        principals,
-        f"{{{TASK_NAMESPACE}}}Principal",
-        {"id": "Author"},
-    )
-    _add_task_element(principal, "UserId", context.user)
-    _add_task_element(principal, "LogonType", "InteractiveToken")
-    _add_task_element(principal, "RunLevel", "LeastPrivilege")
-    settings = _add_task_element(task, "Settings")
-    _add_task_element(settings, "MultipleInstancesPolicy", "IgnoreNew")
-    _add_task_element(settings, "DisallowStartIfOnBatteries", "false")
-    _add_task_element(settings, "StopIfGoingOnBatteries", "false")
-    _add_task_element(settings, "AllowHardTerminate", "true")
-    _add_task_element(settings, "StartWhenAvailable", "true")
-    _add_task_element(settings, "ExecutionTimeLimit", "PT0S")
-    restart = _add_task_element(settings, "RestartOnFailure")
-    _add_task_element(restart, "Interval", "PT5M")
-    _add_task_element(restart, "Count", "3")
-    actions = ElementTree.SubElement(
-        task,
-        f"{{{TASK_NAMESPACE}}}Actions",
-        {"Context": "Author"},
-    )
-    action = _add_task_element(actions, "Exec")
-    _add_task_element(action, "Command", "wscript.exe")
-    _add_task_element(
-        action,
-        "Arguments",
-        f'//B //Nologo "{launcher_path}"',
-    )
-    _add_task_element(action, "WorkingDirectory", str(context.data_dir))
-    return ElementTree.tostring(task, encoding="utf-16", xml_declaration=True)
+    rendered = _WINDOWS_TASK_TEMPLATE.render(
+        {
+            "user": context.user,
+            "managed_marker": MANAGED_MARKER,
+            "arguments": f'//B //Nologo "{launcher_path}"',
+            "data_dir": str(context.data_dir),
+        }
+    )
+    return rendered.encode("utf-16")
 
 
 def _write_managed_file(path: Path, content: str | bytes, *, mode: int) -> None:

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/transport.py

@@ -134,6 +134,13 @@ class LocalCommandServer:
             if (path_stat.st_dev, path_stat.st_ino) == identity:
                 await asyncio.to_thread(path.unlink)
 
+    async def wait_failure(self) -> None:
+        windows_server = self._windows_server
+        if windows_server is not None:
+            await windows_server.wait_failure()
+            return
+        await asyncio.Future()
+
     async def _handle_client(
         self,
         reader: asyncio.StreamReader,

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/app/windows_pipe.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import urlsplit
 
+from bazaar_compute_node.core.lifecycle import TaskFailureSignal
 from bazaar_compute_node.core.paths import resolve_data_dir
 
 RequestHandler = Callable[[Mapping[str, object]], Awaitable[Mapping[str, object]]]
@@ -301,6 +302,7 @@ class WindowsNamedPipeServer:
         self._stop = threading.Event()
         self._ready = threading.Event()
         self._startup_errors: list[BaseException] = []
+        self._failure = TaskFailureSignal()
         self._thread: threading.Thread | None = None
         self._workers: set[threading.Thread] = set()
         self._workers_lock = threading.Lock()
@@ -317,6 +319,7 @@ class WindowsNamedPipeServer:
         self._stop.clear()
         self._ready.clear()
         self._startup_errors.clear()
+        self._failure.reset()
         self._thread = threading.Thread(
             target=self._serve,
             name="bcn-windows-named-pipe",
@@ -332,6 +335,7 @@ class WindowsNamedPipeServer:
             raise TimeoutError("Windows named pipe server did not become ready")
 
     async def stop(self) -> None:
+        self._failure.disable()
         thread = self._thread
         if thread is None:
             _release_mutex(self._mutex)
@@ -352,8 +356,16 @@ class WindowsNamedPipeServer:
         try:
             self._serve_loop()
         except Exception as error:  # noqa: BLE001
-            self._startup_errors.append(error)
-            self._ready.set()
+            if not self._ready.is_set():
+                self._startup_errors.append(error)
+                self._ready.set()
+                return
+            loop = self._loop
+            if loop is not None:
+                loop.call_soon_threadsafe(self._failure.fail, error)
+
+    async def wait_failure(self) -> None:
+        await self._failure.wait()
 
     def _serve_loop(self) -> None:
         initialized = False

{bazaar_compute_node-0.1.27 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/bcc.py

@@ -578,6 +578,13 @@ def serialize_send(result: Mapping[str, object]) -> str:
         ) from error
 
 
+def serialize_unfollow(result: Mapping[str, object]) -> str:
+    target = cast(str, result["target"])
+    if cast(bool, result["changed"]):
+        return f"Thread unfollowed: {target}"
+    return f"Thread was already unfollowed: {target}"
+
+
 def _reminder(result: Mapping[str, object]) -> Mapping[str, object]:
     return cast(Mapping[str, object], result["reminder"])
 
@@ -694,6 +701,8 @@ async def async_main(argv: Sequence[str] | None = None) -> int:
             "cancel": serialize_reminder_cancel,
         }[args.command]
         print(serializer(result))
+    elif args.resource == "thread" and args.command == "unfollow":
+        print(serialize_unfollow(result))
     return 0