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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.28
+Version: 0.1.29
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.28"
+version = "0.1.29"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.28"
+version = "0.1.29"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.28 → 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.28 → 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.28 → 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.28 → 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.28 → 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.28 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/contrib/lark/channel.py

@@ -242,6 +242,7 @@ class LarkChannel(IChannel):
                     self._run_typing_dispatcher(),
                     name="bcn-lark-typing",
                 )
+                self._typing_runner.add_done_callback(self._typing_runner_done)
                 await transport.start(timeout=_remaining(deadline))
                 generation = transport.health.get("connection_generation", 0)
                 self._connection_generation = (
@@ -731,7 +732,9 @@ class LarkChannel(IChannel):
                 isinstance(raw_name, str)
                 and raw_name.strip()
                 and "]" not in raw_name
-                and not any(category(character) == "Cc" for character in raw_name)
+                and not any(
+                    category(character) in {"Cc", "Zl", "Zp"} for character in raw_name
+                )
             ):
                 name = raw_name
             else:
@@ -997,6 +1000,22 @@ class LarkChannel(IChannel):
         if state.terminal or self._typing_stopping:
             self._typing_states.pop(command.session_id, None)
 
+    def _typing_runner_done(self, task: asyncio.Task[None]) -> None:
+        if self._typing_stopping:
+            return
+        error = (
+            RuntimeError("Lark typing dispatcher was canceled unexpectedly")
+            if task.cancelled()
+            else task.exception()
+            or RuntimeError("Lark typing dispatcher stopped unexpectedly")
+        )
+        self._typing_failures += 1
+        _LOGGER.error(
+            "Lark typing dispatcher failed: %s",
+            error,
+            exc_info=(type(error), error, error.__traceback__),
+        )
+
     async def _stop_typing(self, *, timeout: float) -> None:
         self._typing_stopping = True
         runner = self._typing_runner

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/contrib/sqlite/database.py

@@ -198,6 +198,10 @@ class SqliteDatabase:
                 self._executor = None
                 self._schema_version = None
 
+    async def wait_failure(self) -> None:
+        executor = self._require_executor()
+        await executor.wait_failure()
+
     async def fetchone(
         self,
         statement: str,

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/contrib/sqlite/executor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections import deque
 from collections.abc import Awaitable, Callable, Iterable, Sequence
 from contextlib import AbstractAsyncContextManager
@@ -11,6 +12,10 @@ from typing import TypeVar
 
 import aiosqlite
 
+from ...core.lifecycle import TaskFailureSignal
+
+_LOGGER = logging.getLogger(__name__)
+
 T = TypeVar("T")
 
 
@@ -222,6 +227,7 @@ class SqliteExecutor:
         self._write_queue = asyncio.Queue[_WriteRequest[object] | None]()
         self._writer_task: asyncio.Task[None] | None = None
         self._reader_reaper_task: asyncio.Task[None] | None = None
+        self._failure = TaskFailureSignal()
         self._reader_reaper_stop = asyncio.Event()
         self._accepting = False
         self._borrowed_readers = 0
@@ -238,6 +244,7 @@ class SqliteExecutor:
         if self._writer_task is not None:
             return
         self._accepting = True
+        self._failure.reset()
         self._reader_reaper_stop.clear()
         self._writer_task = asyncio.create_task(
             self._run_writer(),
@@ -247,10 +254,17 @@ class SqliteExecutor:
             self._reap_idle_readers(),
             name="bcn-sqlite-reader-reaper",
         )
+        self._failure.observe(self._writer_task, component="SQLite writer")
+        self._reader_reaper_task.add_done_callback(self._reader_reaper_done)
 
     async def stop(self) -> None:
         if self._closed:
             return
+        writer_task = self._writer_task
+        if writer_task is not None and writer_task.done():
+            await self.abort()
+            return
+        self._failure.disable()
         self._accepting = False
         await self._write_queue.join()
         async with self._reader_condition:
@@ -274,6 +288,7 @@ class SqliteExecutor:
         """Interrupt active work and close all connections after a failed drain."""
         if self._closed:
             return
+        self._failure.disable()
         self._accepting = False
         async with self._reader_condition:
             self._reader_condition.notify_all()
@@ -309,10 +324,7 @@ class SqliteExecutor:
         writer_task = self._writer_task
         if writer_task is not None:
             writer_task.cancel()
-            try:
-                await writer_task
-            except asyncio.CancelledError:
-                pass
+            await asyncio.gather(writer_task, return_exceptions=True)
             self._writer_task = None
 
         await self._stop_reader_reaper()
@@ -520,7 +532,15 @@ class SqliteExecutor:
                     to_close.append(reader.connection)
                     excess -= 1
             for connection in to_close:
-                await connection.close()
+                try:
+                    await connection.close()
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    _LOGGER.exception("SQLite idle reader close failed")
+
+    async def wait_failure(self) -> None:
+        await self._failure.wait()
 
     async def _stop_reader_reaper(self) -> None:
         task = self._reader_reaper_task
@@ -530,6 +550,22 @@ class SqliteExecutor:
         await task
         self._reader_reaper_task = None
 
+    def _reader_reaper_done(self, task: asyncio.Task[None]) -> None:
+        if not self._accepting:
+            return
+        self._reader_reaper_task = None
+        error = (
+            RuntimeError("SQLite reader reaper was canceled unexpectedly")
+            if task.cancelled()
+            else task.exception()
+            or RuntimeError("SQLite reader reaper stopped unexpectedly")
+        )
+        _LOGGER.error(
+            "SQLite reader reaper failed: %s",
+            error,
+            exc_info=(type(error), error, error.__traceback__),
+        )
+
     def _require_accepting(self) -> None:
         if not self._accepting:
             raise SqliteExecutorClosedError("SQLite executor is not accepting work")

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.29}/src/bazaar_compute_node/contrib/sqlite/storage.py

@@ -40,7 +40,7 @@ _READ_OPERATIONS = frozenset(
     }
 )
 
-_SNAPSHOT_READ_OPERATIONS = frozenset({"read_message_history"})
+_SNAPSHOT_READ_OPERATIONS = frozenset({"read_inbox_catalog", "read_message_history"})
 
 _TRANSACTIONAL_WRITE_OPERATIONS = frozenset(
     {