bazaar-compute-node 0.1.38__tar.gz → 0.1.39__tar.gz

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.38
+Version: 0.1.39
 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: click>=8.1.0
 Requires-Dist: cryptography>=45.0.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: packaging>=25.0

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.38"
+version = "0.1.39"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -9,6 +9,7 @@ requires-python = ">=3.14"
 dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
+    "click>=8.1.0",
     "cryptography>=45.0.0",
     "jinja2>=3.1.6",
     "packaging>=25.0",

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.38"
+version = "0.1.39"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -9,6 +9,7 @@ requires-python = ">=3.14"
 dependencies = [
     "aiohttp>=3.12.0",
     "aiosqlite>=0.20.0",
+    "click>=8.1.0",
     "cryptography>=45.0.0",
     "jinja2>=3.1.6",
     "packaging>=25.0",

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/src/bazaar_compute_node/app/agent.py

@@ -12,7 +12,7 @@ from dataclasses import dataclass
 from functools import partial
 from pathlib import Path
 
-from ..core.channel import AgentScopedChannel, ChannelContext, IChannel
+from ..core.channel import Channel, ChannelContext, IChannel
 from ..core.concurrency import ISessionConcurrency, SessionLockRegistry
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -113,7 +113,7 @@ class AgentApplication:
                 timer_wheel=self.timer_wheel,
             )
         )
-        self.channel: IChannel = AgentScopedChannel(self.agent_id, provider_channel)
+        self.channel: IChannel = Channel(self.agent_id, provider_channel)
         runtime_contexts: list[RuntimeCommandContext] = []
         runtimes: list[IRuntime] = []
         for index, runtime_configuration in enumerate(configuration.runtimes):
@@ -170,7 +170,7 @@ class AgentApplication:
             ),
             workspace=self.workspace_path,
             translator=self.translator,
-            error_feedback_detail=self._error_feedback_detail,
+            error_feedback_detail=self._redact_session_secrets,
             upgrade_notice=upgrade_notice,
             concurrency=self._concurrency,
         )
@@ -440,21 +440,13 @@ class AgentApplication:
         )
         return environment
 
-    def _error_feedback_detail(
-        self,
-        session_id: object,
-        error_message: object,
-    ) -> str:
-        if not isinstance(session_id, str) or not session_id:
-            raise ValueError("session_id must be a non-empty string")
-        if not isinstance(error_message, str):
-            raise TypeError("error_message must be text")
+    def _redact_session_secrets(self, session_id: str, text: str) -> str:
         binding = self._session_capabilities.get(session_id)
         if binding is None:
-            return error_message
+            return text
         for token in binding.token_values:
-            error_message = error_message.replace(token, "<redacted>")
-        return error_message
+            text = text.replace(token, "<redacted>")
+        return text
 
     async def _run_runtime_command(
         self,

bazaar_compute_node-0.1.39/src/bazaar_compute_node/app/agent_management.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from dataclasses import dataclass, replace
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any
+from uuid import uuid7
+
+from ..core.runtime import RuntimeSandboxMode
+from ..i18n import create_translator
+from .config import (
+    AgentConfiguration,
+    ChannelConfiguration,
+    ConfigurationError,
+    NodeConfiguration,
+    RuntimeConfiguration,
+    _write_configuration,
+    load_node_configuration,
+    resolve_config_path,
+)
+from .usage import Usage
+
+
+@dataclass(frozen=True, slots=True)
+class _SetOptions:
+    agent: dict[str, object]
+    channel: dict[str, object]
+    runtime: dict[str, object]
+    env: dict[str, str]
+
+
+def _set_options(
+    agent_options: Sequence[tuple[str, str, Any]], parser: Usage
+) -> _SetOptions:
+    """Sort every --set value under the scope it names."""
+
+    options = _SetOptions(agent={}, channel={}, runtime={}, env={})
+    seen: set[tuple[str, str]] = set()
+    for scope, key, value in agent_options:
+        # runtime.env accumulates one name per --set; a repeated name is
+        # simply overwritten, the same as a hand-edited config.toml would be
+        if (scope, key) == ("runtime", "env"):
+            options.env.update(value)
+            continue
+        identity = (scope, key)
+        if identity in seen:
+            parser.error(f"duplicate --set option: {scope}.{key}")
+        seen.add(identity)
+        if scope == "agent":
+            options.agent[key] = value
+        elif scope == "channel":
+            options.channel[key] = value
+        else:
+            options.runtime[key] = value
+    return options
+
+
+def _runtime_configuration(
+    kind: str, options: _SetOptions, parser: Usage
+) -> RuntimeConfiguration:
+    """Read the runtime settings out of what --set collected."""
+
+    values = options.runtime
+    model = values.pop("model", None)
+    effort = values.pop("effort", None)
+    raw_sandbox_mode = values.pop(
+        "sandbox_mode",
+        RuntimeSandboxMode.WORKSPACE_WRITE.value,
+    )
+    if not isinstance(raw_sandbox_mode, str):
+        parser.error("runtime.sandbox_mode must be text")
+    try:
+        sandbox_mode = RuntimeSandboxMode(raw_sandbox_mode)
+    except ValueError:
+        allowed = ", ".join(mode.value for mode in RuntimeSandboxMode)
+        parser.error(f"runtime.sandbox_mode must be one of: {allowed}")
+    network_access = values.pop("network_access", True)
+    if not isinstance(network_access, bool):
+        parser.error("runtime.network_access must be a boolean")
+    if model is not None and not isinstance(model, str):
+        parser.error("runtime.model must be text")
+    if effort is not None and not isinstance(effort, str):
+        parser.error("runtime.effort must be text")
+    return RuntimeConfiguration(
+        kind=kind,
+        model=model,
+        effort=effort,
+        sandbox_mode=sandbox_mode,
+        network_access=network_access,
+        env=MappingProxyType(options.env),
+        options=MappingProxyType(values),
+    )
+
+
+def _list_agents(configuration: NodeConfiguration) -> int:
+    if not configuration.agents:
+        print(create_translator(None).text("cli.agent.empty"), flush=True)
+        return 0
+    for agent in configuration.agents:
+        print(
+            f"id={agent.id} name={agent.name} "
+            f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
+            flush=True,
+        )
+    return 0
+
+
+def _add_agent(
+    args: argparse.Namespace,
+    parser: Usage,
+    configuration: NodeConfiguration,
+    config_path: Path,
+) -> int:
+    options = _set_options(args.agent_options, parser)
+
+    idle_timeout = options.agent.pop("idle_timeout", 0)
+    if isinstance(idle_timeout, bool) or not isinstance(idle_timeout, int | float):
+        parser.error("agent.idle_timeout must be a number")
+
+    try:
+        agent = AgentConfiguration(
+            id=str(uuid7()),
+            name=args.name,
+            channel=ChannelConfiguration(
+                kind=args.channel,
+                options=MappingProxyType(options.channel),
+            ),
+            runtimes=(_runtime_configuration(args.runtime, options, parser),),
+            idle_timeout_seconds=idle_timeout,
+        )
+        updated = replace(
+            configuration,
+            agents=(*configuration.agents, agent),
+        )
+        _write_configuration(config_path, updated)
+    except ConfigurationError as error:
+        parser.error(str(error))
+    print(
+        f"Agent added id={agent.id} name={agent.name} "
+        f"channel={agent.channel.kind} runtime={_runtime_kinds(agent)}",
+        flush=True,
+    )
+    print("Run `bcn restart` to apply.", flush=True)
+    return 0
+
+
+def _remove_agent(
+    args: argparse.Namespace,
+    parser: Usage,
+    configuration: NodeConfiguration,
+    config_path: Path,
+) -> int:
+    matches = [
+        agent
+        for agent in configuration.agents
+        if agent.id == args.selector or agent.name == args.selector
+    ]
+    if not matches:
+        parser.error(f"Agent not found: {args.selector}")
+    if len(matches) > 1:
+        parser.error(f"Agent selector is ambiguous: {args.selector}")
+    removed = matches[0]
+    updated = replace(
+        configuration,
+        agents=tuple(agent for agent in configuration.agents if agent.id != removed.id),
+    )
+    try:
+        _write_configuration(config_path, updated)
+    except ConfigurationError as error:
+        parser.error(str(error))
+    print(f"Agent removed id={removed.id} name={removed.name}", flush=True)
+    print("Workspace and durable data were preserved.", flush=True)
+    print("Run `bcn restart` to apply.", flush=True)
+    return 0
+
+
+def run_agent_command(
+    args: argparse.Namespace,
+    parser: Usage,
+) -> int:
+    if (
+        args.storage is not None
+        or args.audit is not None
+        or args.database_name is not None
+        or args.endpoint is not None
+        or args.foreground
+    ):
+        parser.error("bcn agent commands only accept the node-level --config option")
+
+    config_path = (args.config or resolve_config_path()).expanduser()
+    try:
+        configuration = load_node_configuration(config_path)
+    except ConfigurationError as error:
+        parser.error(str(error))
+
+    match args.agent_command:
+        case "list":
+            return _list_agents(configuration)
+        case "add":
+            return _add_agent(args, parser, configuration, config_path)
+        case "remove":
+            return _remove_agent(args, parser, configuration, config_path)
+        case unsupported:
+            raise AssertionError(f"unsupported Agent command: {unsupported}")
+
+
+def _runtime_kinds(agent: AgentConfiguration) -> str:
+    return ",".join(runtime.kind for runtime in agent.runtimes)
+
+
+__all__ = ["run_agent_command"]

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/src/bazaar_compute_node/app/application.py

@@ -19,6 +19,7 @@ from ..core.paths import resolve_data_dir
 from ..core.restart import RESTART_EXIT_CODE
 from ..core.storage import IStorage
 from ..core.timerwheel import TimerWheel
+from ..core.utils.text import format_exception
 from ..i18n import create_translator
 from .agent import AgentApplication
 from .config import AgentConfiguration, NodeConfiguration
@@ -214,7 +215,7 @@ class NodeApplication:
                 runtimes=_runtime_kinds(configuration),
                 status="failed",
                 error_type=type(error).__name__,
-                error=_safe_error(error),
+                error=format_exception(error),
             )
             self.agent_startup_results[configuration.id] = result
             self._log("agent.start.failed", **result.as_health_record())
@@ -265,7 +266,7 @@ class NodeApplication:
                     "agent.stop.failed",
                     agent_id=agent_id,
                     error_type=type(error).__name__,
-                    error=_safe_error(error),
+                    error=format_exception(error),
                 )
         self.agents.clear()
         try:
@@ -349,7 +350,7 @@ class NodeApplication:
                     "bcn.critical.failed",
                     component=component,
                     error_type=type(error).__name__,
-                    error=_safe_error(error),
+                    error=format_exception(error),
                 )
                 raise error
         finally:
@@ -381,7 +382,7 @@ class NodeApplication:
                 agent_id=agent_id,
                 owner_session_id=message.session_id,
                 error_type=type(error).__name__,
-                error=_safe_error(error),
+                error=format_exception(error),
             )
             return False
         return True
@@ -508,9 +509,4 @@ class NodeApplication:
         )
 
 
-def _safe_error(error: BaseException) -> str:
-    message = str(error).strip()
-    return message or type(error).__name__
-
-
 __all__ = ["AgentStartupResult", "NodeApplication"]

{bazaar_compute_node-0.1.38 → bazaar_compute_node-0.1.39}/src/bazaar_compute_node/app/attachments.py

@@ -61,6 +61,75 @@ class AttachmentMaterializer:
                 continue
             await asyncio.to_thread(shutil.rmtree, path)
 
+    async def _stage(
+        self,
+        source: bytes | AsyncIterable[bytes],
+        temporary: Path,
+        destination: Path,
+        root: Path,
+    ) -> int:
+        """Write an attachment aside, then move it into place once it is whole."""
+
+        current_size = await asyncio.to_thread(self._stored_size, root)
+        descriptor: int | None = None
+        try:
+            descriptor = await asyncio.to_thread(
+                os.open,
+                temporary,
+                os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0),
+                0o600,
+            )
+            try:
+                size = await self._write(descriptor, source, current_size)
+                await asyncio.to_thread(os.fsync, descriptor)
+                stored = await asyncio.to_thread(os.fstat, descriptor)
+                if stored.st_size != size:
+                    raise OSError(
+                        "attachment write size mismatch: "
+                        f"expected {size}, got {stored.st_size}"
+                    )
+            finally:
+                await asyncio.to_thread(os.close, descriptor)
+                descriptor = None
+            await asyncio.to_thread(destination.parent.mkdir, parents=True, mode=0o700)
+            await asyncio.to_thread(os.replace, temporary, destination)
+            if os.name != "nt":
+                await asyncio.to_thread(destination.chmod, 0o600)
+            return size
+        except BaseException:
+            if descriptor is not None:
+                await asyncio.to_thread(os.close, descriptor)
+            if await asyncio.to_thread(temporary.exists):
+                await asyncio.to_thread(temporary.unlink)
+            raise
+
+    async def _write(
+        self,
+        descriptor: int,
+        source: bytes | AsyncIterable[bytes],
+        current_size: int,
+    ) -> int:
+        """Write the source through, refusing it the moment it goes over a limit."""
+
+        if isinstance(source, bytes):
+            self._check_room(len(source), current_size)
+            await asyncio.to_thread(_write_all, descriptor, source)
+            return len(source)
+        size = 0
+        async for chunk in source:
+            if not isinstance(chunk, bytes):
+                raise TypeError("attachment stream must yield bytes")
+            size += len(chunk)
+            self._check_room(size, current_size)
+            await asyncio.to_thread(_write_all, descriptor, chunk)
+        return size
+
+    def _check_room(self, size: int, current_size: int) -> None:
+        if size > self._max_file_bytes:
+            raise ValueError("attachment exceeds the per-file size limit")
+        if current_size + size > self._max_workspace_bytes:
+            raise ValueError("attachment workspace quota exceeded")
+
     async def materialize(
         self,
         source: bytes | AsyncIterable[bytes],
@@ -84,64 +153,7 @@ class AttachmentMaterializer:
             await asyncio.to_thread(
                 staging.mkdir, parents=True, exist_ok=True, mode=0o700
             )
-            current_size = await asyncio.to_thread(self._stored_size, root)
-            size = 0
-            descriptor: int | None = None
-            try:
-                open_flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
-                binary_flag = getattr(os, "O_BINARY", None)
-                if binary_flag is not None:
-                    open_flags |= binary_flag
-                descriptor = await asyncio.to_thread(
-                    os.open,
-                    temporary,
-                    open_flags,
-                    0o600,
-                )
-                try:
-                    if isinstance(source, bytes):
-                        size = len(source)
-                        if size > self._max_file_bytes:
-                            raise ValueError(
-                                "attachment exceeds the per-file size limit"
-                            )
-                        if current_size + size > self._max_workspace_bytes:
-                            raise ValueError("attachment workspace quota exceeded")
-                        await asyncio.to_thread(_write_all, descriptor, source)
-                    else:
-                        async for chunk in source:
-                            if not isinstance(chunk, bytes):
-                                raise TypeError("attachment stream must yield bytes")
-                            size += len(chunk)
-                            if size > self._max_file_bytes:
-                                raise ValueError(
-                                    "attachment exceeds the per-file size limit"
-                                )
-                            if current_size + size > self._max_workspace_bytes:
-                                raise ValueError("attachment workspace quota exceeded")
-                            await asyncio.to_thread(_write_all, descriptor, chunk)
-                    await asyncio.to_thread(os.fsync, descriptor)
-                    stored_size = await asyncio.to_thread(os.fstat, descriptor)
-                    if stored_size.st_size != size:
-                        raise OSError(
-                            "attachment write size mismatch: "
-                            f"expected {size}, got {stored_size.st_size}"
-                        )
-                finally:
-                    await asyncio.to_thread(os.close, descriptor)
-                    descriptor = None
-                await asyncio.to_thread(
-                    destination.parent.mkdir, parents=True, mode=0o700
-                )
-                await asyncio.to_thread(os.replace, temporary, destination)
-                if os.name != "nt":
-                    await asyncio.to_thread(destination.chmod, 0o600)
-            except BaseException:
-                if descriptor is not None:
-                    await asyncio.to_thread(os.close, descriptor)
-                if await asyncio.to_thread(temporary.exists):
-                    await asyncio.to_thread(temporary.unlink)
-                raise
+            size = await self._stage(source, temporary, destination, root)
         return InboundAttachment(
             attachment_id=attachment_id,
             name=Path(name).name,