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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.28
+Version: 0.1.30
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -110,7 +110,7 @@ Windows: Get-Content "$env:USERPROFILE\.bcn\system-service.log" -Wait
 | Status / 状态 | Runtime / 运行时 |
 | --- | --- |
 | ✅ | Codex |
-| 🚧 | Claude Code |
+| ✅ | Claude Code |
 | 🚧 | Pi |
 | 🚧 | Hermes Agent |
 | 🚧 | DeepSeek Harness |

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.30}/README.md

@@ -93,7 +93,7 @@ Windows: Get-Content "$env:USERPROFILE\.bcn\system-service.log" -Wait
 | Status / 状态 | Runtime / 运行时 |
 | --- | --- |
 | ✅ | Codex |
-| 🚧 | Claude Code |
+| ✅ | Claude Code |
 | 🚧 | Pi |
 | 🚧 | Hermes Agent |
 | 🚧 | DeepSeek Harness |

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.28"
+version = "0.1.30"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -24,6 +24,7 @@ bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
 codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
+claudecode = "bazaar_compute_node.contrib.claude.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:builder"

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.28"
+version = "0.1.30"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -24,6 +24,7 @@ bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
 codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
+claudecode = "bazaar_compute_node.contrib.claude.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:builder"

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.30}/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.30}/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
@@ -117,8 +117,12 @@ class NodeApplication:
 
         self._started = True
         self._stopped.clear()
-        for agent_configuration in self.configuration.agents:
-            await self._start_agent(agent_configuration)
+        async with asyncio.TaskGroup() as group:
+            for agent_configuration in self.configuration.agents:
+                group.create_task(
+                    self._start_agent(agent_configuration),
+                    name=f"bcn-agent-start-{agent_configuration.id}",
+                )
         try:
             await self.reminder_scheduler.start(
                 timeout=self.timeout_budget.startup_seconds,
@@ -141,26 +145,27 @@ class NodeApplication:
     async def _start_agent(self, configuration: AgentConfiguration) -> None:
         application: AgentApplication | None = None
         try:
-            factories = await asyncio.to_thread(
-                self._registry.load_agent,
-                channel=configuration.channel.kind,
-                runtime=configuration.runtime.kind,
-                storage=self.configuration.storage,
-            )
-            storage_scope = self.storage.scope(configuration.id, configuration.name)
-            application = AgentApplication(
-                configuration=configuration,
-                factories=factories,
-                storage=storage_scope,
-                audit=self.audit,
-                timer_wheel=self.timer_wheel,
-                reminder_concurrency=self._reminder_concurrency,
-                reminder_poke=self.reminder_scheduler.poke,
-                endpoint=lambda: self.endpoint,
-                timeout_budget=self.timeout_budget,
-                translator=self.translator,
-            )
-            await application.start()
+            async with asyncio.timeout(self.timeout_budget.startup_seconds):
+                factories = await asyncio.to_thread(
+                    self._registry.load_agent,
+                    channel=configuration.channel.kind,
+                    runtime=configuration.runtime.kind,
+                    storage=self.configuration.storage,
+                )
+                storage_scope = self.storage.scope(configuration.id, configuration.name)
+                application = AgentApplication(
+                    configuration=configuration,
+                    factories=factories,
+                    storage=storage_scope,
+                    audit=self.audit,
+                    timer_wheel=self.timer_wheel,
+                    reminder_concurrency=self._reminder_concurrency,
+                    reminder_poke=self.reminder_scheduler.poke,
+                    endpoint=lambda: self.endpoint,
+                    timeout_budget=self.timeout_budget,
+                    translator=self.translator,
+                )
+                await application.start()
         except asyncio.CancelledError:
             if application is not None:
                 await self._stop_agent_after_failed_start(application)
@@ -245,7 +250,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,
@@ -356,7 +415,8 @@ class NodeApplication:
 
     async def _stop_agent_after_failed_start(self, agent: AgentApplication) -> None:
         try:
-            await agent.stop()
+            async with asyncio.timeout(self.timeout_budget.shutdown_seconds):
+                await agent.stop()
         except BaseException as error:
             self._logger.debug(
                 "agent cleanup after failed start failed",

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.30}/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.30}/src/bazaar_compute_node/app/transport.py

@@ -12,6 +12,8 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlsplit
 
+from ..core.utils import UnlimitedLineReader
+
 RequestHandler = Callable[[Mapping[str, object]], Awaitable[Mapping[str, object]]]
 StreamPair = tuple[asyncio.StreamReader, asyncio.StreamWriter]
 
@@ -134,13 +136,20 @@ 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,
         writer: asyncio.StreamWriter,
     ) -> None:
         try:
-            line = await reader.readline()
+            line = await UnlimitedLineReader(reader).readline()
             if not line:
                 return
             payload = json.loads(line)
@@ -260,7 +269,7 @@ class LocalCommandClient:
                 + b"\n"
             )
             await writer.drain()
-            line = await reader.readline()
+            line = await UnlimitedLineReader(reader).readline()
             if not line:
                 raise ConnectionError("local command server closed without a response")
             response = json.loads(line)

{bazaar_compute_node-0.1.28 → bazaar_compute_node-0.1.30}/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.30/src/bazaar_compute_node/contrib/claude/__init__.py

@@ -0,0 +1,28 @@
+"""Claude Code streaming process, protocol, and runtime adapter."""
+
+from .client import Client
+from .events import TurnEventStream
+from .process import ProcessSpec, ProcessState, ProcessSupervisor, build_arguments
+from .protocol import (
+    ClaudeControlError,
+    ClaudeProcessExited,
+    ClaudeProcessNotRunning,
+    ClaudeProtocolError,
+    ClaudeTransportError,
+)
+from .runtime import Runtime
+
+__all__ = [
+    "ClaudeControlError",
+    "ClaudeProcessExited",
+    "ClaudeProcessNotRunning",
+    "ClaudeProtocolError",
+    "ClaudeTransportError",
+    "Client",
+    "ProcessSpec",
+    "ProcessState",
+    "ProcessSupervisor",
+    "Runtime",
+    "TurnEventStream",
+    "build_arguments",
+]