bazaar-compute-node 0.1.36__tar.gz → 0.1.37__tar.gz

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/PKG-INFO

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

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/pyproject.toml

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

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/pyproject.toml.orig

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

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/app/agent.py

@@ -79,7 +79,7 @@ class AgentApplication:
         endpoint: Callable[[], str],
         timeout_budget: TimeoutBudget,
         translator: Translator,
-        upgrade_service: UpgradeService,
+        upgrade_service: UpgradeService | None,
         upgrade_notice: Callable[[], tuple[str, str] | None] = lambda: None,
     ) -> None:
         self.configuration = configuration

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/app/application.py

@@ -24,7 +24,7 @@ from .agent import AgentApplication
 from .config import AgentConfiguration, NodeConfiguration
 from .registry import AdapterRegistry, SharedAdapterFactories
 from .transport import LocalCommandServer
-from .upgrade import UpgradeService, discard_replaced_release
+from .upgrade import UpgradeService
 from .version_check import VersionWatcher
 
 
@@ -94,10 +94,16 @@ class NodeApplication:
             request_timeout_seconds=self.timeout_budget.command_seconds,
         )
         self._restart_requested = False
-        self.upgrade_service = UpgradeService(
-            available_version=self.version_watcher.available_version,
-            installed_version=__version__,
-            request_restart=self.request_restart,
+        # Windows has nothing that brings the node back after it exits, so
+        # there it offers no upgrade command at all
+        self.upgrade_service = (
+            None
+            if os.name == "nt"
+            else UpgradeService(
+                available_version=self.version_watcher.available_version,
+                installed_version=__version__,
+                request_restart=self.request_restart,
+            )
         )
         self.command_server = LocalCommandServer(
             self._dispatch,
@@ -155,7 +161,6 @@ class NodeApplication:
             raise
         self._ready = True
         self._accepting = True
-        await asyncio.to_thread(discard_replaced_release, __version__)
         started_count = len(self.agents)
         failed_count = len(self.configuration.agents) - started_count
         self._log(

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/app/resource_dispatch.py

@@ -195,7 +195,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
         reminder_service: IReminderService,
         timeout_budget: TimeoutBudget,
         session_binding_validator: SessionBindingValidator | None = None,
-        upgrade_service: UpgradeService,
+        upgrade_service: UpgradeService | None,
     ) -> None:
         super().__init__(
             service,
@@ -247,6 +247,14 @@ class CommandDispatcher(_MessageCommandDispatcher):
         if resource == "inbox":
             return await super()._dispatch_command(raw_request)
         if resource == "node":
+            upgrade_service = self._upgrade_service
+            if upgrade_service is None:
+                # nothing on this platform would bring the node back after an
+                # upgrade exits it, so the Agent is given no upgrade to run
+                raise CommandDispatchError(
+                    "UNKNOWN_RESOURCE",
+                    f"unsupported command resource: {resource}",
+                )
             if command not in {"upgrade", "version"}:
                 raise CommandDispatchError(
                     "UNKNOWN_COMMAND",
@@ -256,7 +264,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
                 return {
                     "ok": True,
                     "result": {
-                        "version": self._upgrade_service.installed_version,
+                        "version": upgrade_service.installed_version,
                     },
                 }
             request = _parse_command_request(
@@ -275,6 +283,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
             return await self._dispatch_upgrade(
                 session_id,
                 cast(_NodeUpgradeRequest, request),
+                upgrade_service,
             )
         if resource != "reminder":
             raise CommandDispatchError(
@@ -311,6 +320,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
         self,
         session_id: str,
         request: _NodeUpgradeRequest,
+        upgrade_service: UpgradeService,
     ) -> Mapping[str, object]:
         async def wake_after(upgrade_version: str) -> str | None:
             # the reminder is how the Agent is prompted to check the node over
@@ -335,7 +345,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
             return result.reminder.reminder_id
 
         try:
-            upgrade_version, reminder_id = await self._upgrade_service.upgrade(
+            upgrade_version, reminder_id = await upgrade_service.upgrade(
                 wake_after=wake_after,
             )
         except UpgradeUnavailable as error:
@@ -355,7 +365,7 @@ class CommandDispatcher(_MessageCommandDispatcher):
         return {
             "ok": True,
             "result": {
-                "installed_version": self._upgrade_service.installed_version,
+                "installed_version": upgrade_service.installed_version,
                 "upgrade_version": upgrade_version,
                 "reminder_id": reminder_id,
             },

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/app/system_service.py

@@ -6,7 +6,6 @@ import getpass
 import locale
 import os
 import platform
-import re
 import shlex
 import shutil
 import subprocess
@@ -16,9 +15,7 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 
-from .. import __distribution__
 from ..core.paths import resolve_data_dir
-from ..core.restart import RESTART_EXIT_CODE
 from ..i18n import Translator, create_translator
 from ..rendering import TextTemplate
 from .config import ConfigurationError, load_control_configuration, resolve_config_path
@@ -28,10 +25,6 @@ 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."
-# raised whenever a managed file's content changes, so an upgrade can tell that
-# the installed copy predates what this release expects of it
-TEMPLATE_REVISION = 1
-MANAGED_MARKER_LINE = f"{MANAGED_MARKER} template-revision={TEMPLATE_REVISION}"
 WINDOWS_STOP_ATTEMPTS = 100
 WINDOWS_STOP_INTERVAL = 0.05
 
@@ -180,7 +173,7 @@ def _powershell_literal(path: Path | str | None) -> str:
 def _render_systemd_unit(context: SystemServiceContext) -> str:
     return _SYSTEMD_UNIT_TEMPLATE.render(
         {
-            "managed_marker": MANAGED_MARKER_LINE,
+            "managed_marker": MANAGED_MARKER,
             "executable": _systemd_quote(_require_executable(context)),
             "config_path": _systemd_quote(context.config_path),
             "data_dir": _systemd_quote(context.data_dir),
@@ -192,7 +185,7 @@ def _render_systemd_unit(context: SystemServiceContext) -> str:
 
 
 def _render_launchd_wrapper() -> str:
-    return _LAUNCHD_WRAPPER_TEMPLATE.render({"managed_marker": MANAGED_MARKER_LINE})
+    return _LAUNCHD_WRAPPER_TEMPLATE.render({"managed_marker": MANAGED_MARKER})
 
 
 def _render_launchd_plist(
@@ -202,7 +195,7 @@ def _render_launchd_plist(
     return _LAUNCHD_PLIST_TEMPLATE.render(
         {
             "label": LAUNCHD_LABEL,
-            "managed_marker": MANAGED_MARKER_LINE,
+            "managed_marker": MANAGED_MARKER,
             "wrapper_path": str(wrapper_path),
             "data_dir": str(context.data_dir),
             "config_path": str(context.config_path),
@@ -215,70 +208,18 @@ def _render_launchd_plist(
     ).encode("utf-8")
 
 
-def render_windows_wrapper(
-    *,
-    executable: str,
-    config_path: str,
-    environment_script: str,
-    log_path: str,
-) -> str:
-    """Render the launcher from PowerShell literals, however they were obtained."""
-
+def _render_windows_wrapper(context: SystemServiceContext) -> str:
     return _WINDOWS_WRAPPER_TEMPLATE.render(
         {
-            "managed_marker": MANAGED_MARKER_LINE,
-            "executable": executable,
-            "config_path": config_path,
-            "environment_script": environment_script,
-            "log_path": log_path,
-            "distribution": _powershell_literal(__distribution__),
-            "restart_exit_code": RESTART_EXIT_CODE,
+            "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 _render_windows_wrapper(context: SystemServiceContext) -> str:
-    return render_windows_wrapper(
-        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 windows_wrapper_path() -> Path:
-    """Return where the launcher lives, without needing the install arguments."""
-
-    return resolve_data_dir() / "bcn-system-service.ps1"
-
-
-def windows_tool_directory() -> Path | None:
-    """Return the directory uv keeps its installed tools in, where there is one."""
-
-    configured = os.environ.get("UV_TOOL_DIR")
-    if configured:
-        return Path(configured).expanduser()
-    app_data = os.environ.get("APPDATA")
-    return None if not app_data else Path(app_data) / "uv" / "tools"
-
-
-def windows_live_directory() -> Path | None:
-    """Return the installed tool directory an upgrade swaps into place."""
-
-    tools = windows_tool_directory()
-    return None if tools is None else tools / __distribution__
-
-
-def installed_template_revision(content: str) -> int | None:
-    """Read the revision a managed file was written from, if it declares one."""
-
-    first_line = content.splitlines()[0] if content else ""
-    if MANAGED_MARKER not in first_line:
-        return None
-    match = re.search(r"template-revision=(\d+)", first_line)
-    return int(match.group(1)) if match is not None else None
-
-
 def _vbs_literal(value: Path | str) -> str:
     return '"' + str(value).replace('"', '""') + '"'
 
@@ -290,7 +231,7 @@ def _render_windows_launcher(wrapper_path: Path) -> str:
     )
     return _WINDOWS_LAUNCHER_TEMPLATE.render(
         {
-            "managed_marker": MANAGED_MARKER_LINE,
+            "managed_marker": MANAGED_MARKER,
             "command": command,
         }
     )
@@ -303,7 +244,7 @@ def _render_windows_task(
     rendered = _WINDOWS_TASK_TEMPLATE.render(
         {
             "user": context.user,
-            "managed_marker": MANAGED_MARKER_LINE,
+            "managed_marker": MANAGED_MARKER,
             "arguments": f'//B //Nologo "{launcher_path}"',
             "data_dir": str(context.data_dir),
         }

bazaar_compute_node-0.1.37/src/bazaar_compute_node/app/upgrade.py

@@ -0,0 +1,151 @@
+"""Install a newer bcn release and hand this node over to it."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import subprocess
+from collections.abc import Awaitable, Callable, Mapping
+
+from packaging.version import InvalidVersion, Version
+
+from .. import __distribution__
+
+# uv writes UTF-8 whatever the console is set to, so a node in a non-UTF-8
+# locale would otherwise report its diagnostics as mojibake
+_UV_OUTPUT_ENCODING = "utf-8"
+
+
+class UpgradeError(RuntimeError):
+    """Raised when the node cannot install or hand over to the new release."""
+
+
+class UpgradeUnavailable(UpgradeError):
+    """Raised when no newer release has been announced."""
+
+
+def _uv_executable() -> str:
+    executable = shutil.which("uv")
+    if executable is None:
+        # a node started by a service manager inherits that manager's PATH,
+        # which often does not include wherever uv was installed, so this says
+        # nothing about whether uv exists on the machine
+        raise UpgradeError(
+            "uv is not on this node's PATH, so the release cannot be "
+            "installed; add the directory holding uv to the PATH the node "
+            "runs with, then try again"
+        )
+    return executable
+
+
+def _run(
+    command: list[str],
+    *,
+    env: Mapping[str, str] | None = None,
+    encoding: str | None = None,
+) -> None:
+    # no deadline: uv already gives up on a request that never answers, and a
+    # second limit would only cut short an install that was merely slow
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        check=False,
+        text=True,
+        encoding=encoding,
+        errors="replace",
+        env=None if env is None else {**os.environ, **env},
+    )
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout).strip()
+        suffix = f": {detail}" if detail else ""
+        raise UpgradeError(
+            f"upgrade command failed ({result.returncode}): {' '.join(command)}{suffix}"
+        )
+
+
+def _install(version: str) -> None:
+    _run(
+        [
+            _uv_executable(),
+            "tool",
+            "install",
+            "--force",
+            # the release was announced by PyPI's own API minutes ago, while uv
+            # resolves against a separately cached index that can still predate
+            # it and would then report the version as one that does not exist
+            "--refresh-package",
+            __distribution__,
+            f"{__distribution__}=={version}",
+        ],
+        encoding=_UV_OUTPUT_ENCODING,
+    )
+
+
+class UpgradeService:
+    """Install the release the user agreed to, then hand the node over to it."""
+
+    def __init__(
+        self,
+        *,
+        available_version: Callable[[], str | None],
+        installed_version: str,
+        request_restart: Callable[[], None],
+    ) -> None:
+        self._available_version = available_version
+        self._installed_version = installed_version
+        self._request_restart = request_restart
+        self._lock = asyncio.Lock()
+
+    @property
+    def installed_version(self) -> str:
+        return self._installed_version
+
+    def available_version(self) -> str | None:
+        return self._available_version()
+
+    async def upgrade(
+        self,
+        *,
+        wake_after: Callable[[str], Awaitable[str | None]],
+    ) -> tuple[str, str | None]:
+        """Install the release on offer and hand the node over to it.
+
+        The whole thing is one transaction. Two sessions can accept an offer at
+        the same time, and by then the offers need not even name the same
+        release; letting the second in before the first has asked to restart
+        would boot a version nobody was told about, and an install cannot be
+        called back once its thread is running.
+
+        ``wake_after`` records how the Agent is prompted to check the node over
+        afterwards, and returns the reminder it left, or None if it could not
+        leave one.
+        """
+
+        async with self._lock:
+            version = self.available_version()
+            if version is None:
+                raise UpgradeUnavailable(
+                    "No newer release has been announced for this node."
+                )
+            try:
+                Version(version)
+            except InvalidVersion as error:
+                raise UpgradeError(f"{version!r} is not a release version") from error
+            await self.install(version)
+            reminder_id = await wake_after(version)
+            # the node cannot restart itself from the inside: on Windows the
+            # stop it would ask for kills the process tree it is asking from.
+            # Exiting is the one thing it can do that its host watches for.
+            self._request_restart()
+            return version, reminder_id
+
+    async def install(self, version: str) -> None:
+        await asyncio.to_thread(_install, version)
+
+
+__all__ = [
+    "UpgradeError",
+    "UpgradeService",
+    "UpgradeUnavailable",
+]

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/bcc.py

@@ -24,6 +24,10 @@ from .app.transport import LocalCommandClient
 from .core.reminder import format_utc_timestamp
 from .rendering import TextTemplate
 
+# Windows has nothing that brings the node back after an upgrade exits it, so
+# there the node offers no upgrade and the commands would only ever be refused
+_NODE_COMMANDS_HIDDEN = os.name == "nt"
+
 
 class BccCommandError(RuntimeError):
     def __init__(
@@ -47,8 +51,8 @@ def build_parser() -> argparse.ArgumentParser:
         description=(
             "Session-scoped collaboration commands for a Bazaar Compute Node. "
             "Use these commands from the current agent session to inspect messages, "
-            "send replies, manage thread attention, schedule "
-            "persistent reminders, and upgrade this node."
+            "send replies, manage thread attention, and schedule "
+            "persistent reminders."
         ),
         epilog=(
             "Run `bcc <resource> --help` or "
@@ -58,7 +62,11 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(
         dest="resource",
         required=True,
-        metavar="{message,inbox,thread,reminder,node}",
+        metavar=(
+            "{message,inbox,thread,reminder}"
+            if _NODE_COMMANDS_HIDDEN
+            else "{message,inbox,thread,reminder,node}"
+        ),
         title="resources",
     )
 
@@ -330,6 +338,9 @@ def build_parser() -> argparse.ArgumentParser:
         help="Reminder id (full uuid)",
     )
 
+    if _NODE_COMMANDS_HIDDEN:
+        return parser
+
     node_parser = subparsers.add_parser(
         "node",
         help="Operations on the node this session runs on",

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/core/orchestration/turn.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
 from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass, replace
 
@@ -144,6 +145,9 @@ def inbox_notice(
             "rows": [row[2] for row in rows],
             "upgrade_version": upgrade_version,
             "installed_version": installed_version,
+            # Windows has nothing that would bring the node back after an
+            # upgrade exits it, so there the user runs the commands themselves
+            "manual_upgrade": os.name == "nt",
             "closing_bracket_on_own_line": closing_bracket_on_own_line,
         }
     )

{bazaar_compute_node-0.1.36 → bazaar_compute_node-0.1.37}/src/bazaar_compute_node/resources/inbox_notice.tpl

@@ -1,5 +1,5 @@
 [inbox notice:
 Inbox update: {{ total_unread_count }} unread {{ "message" if total_unread_count == 1 else "messages" }} total; {{ rows | length }} changed {{ "target" if rows | length == 1 else "targets" }}{% for row in rows %}
 {{ row.target }}  pending: {{ row.pending_count }} {{ "message" if row.pending_count == 1 else "messages" }} · first msg={{ row.first_id }}{% if row.latest_sender is not none %} · latest sender @{{ row.latest_sender }}{% endif %} · latest msg={{ row.latest_id }}{% for flag in row.flags %} · {{ "you were mentioned" if flag == "mention" else flag }}{% endfor %}{% endfor %}{% if upgrade_version is not none and installed_version is not none %}
-Upgrade available: {{ distribution }} {{ upgrade_version }} (installed {{ installed_version }}). Mention it in passing when you reply and offer to upgrade; if the user agrees, run `bcc node upgrade`. If they do not want it, just carry on.{% endif %}{% if closing_bracket_on_own_line %}
+Upgrade available: {{ distribution }} {{ upgrade_version }} (installed {{ installed_version }}). Mention it in passing when you reply and offer to upgrade. {% if manual_upgrade %}Upgrading is theirs to run on this platform: if they want it, give them these three commands in this order, and say the second one needs the node stopped: `bcn system-service stop`, `uv tool install --force --refresh-package {{ distribution }} {{ distribution }}=={{ upgrade_version }}`, `bcn system-service start`.{% else %}If the user agrees, run `bcc node upgrade`.{% endif %} If they do not want it, just carry on.{% endif %}{% if closing_bracket_on_own_line %}
 {% endif %}]{{ "" -}}

bazaar_compute_node-0.1.37/src/bazaar_compute_node/resources/system_service/windows.ps1

@@ -0,0 +1,98 @@
+# {{ managed_marker }}
+$ErrorActionPreference = 'Stop'
+
+$executable = {{ executable }}
+$configPath = {{ config_path }}
+$environmentScript = {{ environment_script }}
+$logPath = {{ log_path }}
+
+try {
+    Add-Type -TypeDefinition @'
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+
+public static class BcnNoWindowProcess
+{
+    public static int Run(string executable, string configPath, string logPath)
+    {
+        ProcessStartInfo startInfo = new ProcessStartInfo();
+        startInfo.FileName = executable;
+        startInfo.Arguments = "run --config \"" + configPath + "\"";
+        startInfo.UseShellExecute = false;
+        startInfo.CreateNoWindow = true;
+        startInfo.RedirectStandardInput = true;
+        startInfo.RedirectStandardOutput = true;
+        startInfo.RedirectStandardError = true;
+
+        using (Process process = new Process())
+        using (FileStream logStream = new FileStream(
+            logPath,
+            FileMode.Append,
+            FileAccess.Write,
+            FileShare.ReadWrite | FileShare.Delete
+        ))
+        {
+            process.StartInfo = startInfo;
+            process.Start();
+            process.StandardInput.Close();
+
+            object writeLock = new object();
+            Task stdoutTask = CopyToLogAsync(
+                process.StandardOutput.BaseStream,
+                logStream,
+                writeLock
+            );
+            Task stderrTask = CopyToLogAsync(
+                process.StandardError.BaseStream,
+                logStream,
+                writeLock
+            );
+
+            process.WaitForExit();
+            Task.WaitAll(stdoutTask, stderrTask);
+            return process.ExitCode;
+        }
+    }
+
+    private static async Task CopyToLogAsync(
+        Stream source,
+        Stream destination,
+        object writeLock
+    )
+    {
+        byte[] buffer = new byte[8192];
+        int bytesRead;
+        while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length)) > 0)
+        {
+            lock (writeLock)
+            {
+                destination.Write(buffer, 0, bytesRead);
+                destination.Flush();
+            }
+        }
+    }
+}
+'@
+} catch {
+    $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
+    exit 1
+}
+
+if ($environmentScript -and (Test-Path -LiteralPath $environmentScript)) {
+    try {
+        . $environmentScript
+    } catch {
+        $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
+        exit 1
+    }
+}
+
+try {
+    $exitCode = [BcnNoWindowProcess]::Run($executable, $configPath, $logPath)
+} catch {
+    $_ | Out-String | Add-Content -LiteralPath $logPath -Encoding utf8
+    exit 1
+}
+exit $exitCode