bazaar-compute-node 0.1.4__tar.gz → 0.1.6__tar.gz

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.4
+Version: 0.1.6
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -167,7 +167,9 @@ uvx --from 'git+https://github.com/yuchanns/bazaar-compute-node@main' bcn restar
 uvx --from 'git+https://github.com/yuchanns/bazaar-compute-node@main' bcn --help
 ```
 
-节点数据默认保存在 `~/.bcn`。停止节点会优雅关闭后台进程，不会删除既有会话、工作区或消息记录。
+节点数据默认保存在 `~/.bcn`。可通过 `BCN_DATA_NAME` 指定 HOME 下的另一数据目录名称，
+例如 `BCN_DATA_NAME=.bcn-test`；该值必须是单个目录名。停止节点会优雅关闭后台进程，
+不会删除既有会话、工作区或消息记录。
 
 ## 许可证
 

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/README.md

@@ -154,7 +154,9 @@ uvx --from 'git+https://github.com/yuchanns/bazaar-compute-node@main' bcn restar
 uvx --from 'git+https://github.com/yuchanns/bazaar-compute-node@main' bcn --help
 ```
 
-节点数据默认保存在 `~/.bcn`。停止节点会优雅关闭后台进程，不会删除既有会话、工作区或消息记录。
+节点数据默认保存在 `~/.bcn`。可通过 `BCN_DATA_NAME` 指定 HOME 下的另一数据目录名称，
+例如 `BCN_DATA_NAME=.bcn-test`；该值必须是单个目录名。停止节点会优雅关闭后台进程，
+不会删除既有会话、工作区或消息记录。
 
 ## 许可证
 

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.4"
+version = "0.1.6"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -43,7 +43,8 @@ path = "tests/support"
 editable = true
 
 [tool.pytest.ini_options]
-markers = ["real_home: run against the actual user home and persistent node data directory"]
+addopts = "-m 'not e2e'"
+markers = ["e2e: requires a real external provider"]
 
 [build-system]
 requires = ["uv_build>=0.12.2,<0.13.0"]

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.4"
+version = "0.1.6"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -41,11 +41,12 @@ dev = [
 [tool.uv.sources]
 bcn-test-support = { path = "tests/support", editable = true }
 
-[build-system]
-requires = ["uv_build>=0.12.2,<0.13.0"]
-build-backend = "uv_build"
-
 [tool.pytest.ini_options]
+addopts = "-m 'not e2e'"
 markers = [
-    "real_home: run against the actual user home and persistent node data directory",
+    "e2e: requires a real external provider",
 ]
+
+[build-system]
+requires = ["uv_build>=0.12.2,<0.13.0"]
+build-backend = "uv_build"

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/application.py

@@ -114,6 +114,7 @@ class NodeApplication:
             storage=self.storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
+            workspace=self._workspace_path,
             on_node_initialized=self._ensure_workspace,
         )
         self.command_service = self.orchestrator.command_service
@@ -139,10 +140,12 @@ class NodeApplication:
     async def start(self) -> None:
         if self._started:
             return
-        self.data_dir.mkdir(parents=True, exist_ok=True)
+        await asyncio.to_thread(self.data_dir.mkdir, parents=True, exist_ok=True)
         if os.name != "nt":
-            self.data_dir.chmod(0o700)
-        self._wrapper_path = install_bcc_wrapper(self.data_dir / "bin")
+            await asyncio.to_thread(self.data_dir.chmod, 0o700)
+        self._wrapper_path = await asyncio.to_thread(
+            install_bcc_wrapper, self.data_dir / "bin"
+        )
         try:
             await self.command_server.start()
             await self.orchestrator.start(
@@ -165,7 +168,7 @@ class NodeApplication:
                 try:
                     await self.command_server.stop()
                 finally:
-                    self._cleanup_bcc_wrapper()
+                    await self._cleanup_bcc_wrapper()
             return
         self._started = False
         self.command_dispatcher.stop_accepting()
@@ -183,15 +186,15 @@ class NodeApplication:
                     await self.command_server.stop()
                 finally:
                     try:
-                        self._cleanup_bcc_wrapper()
+                        await self._cleanup_bcc_wrapper()
                     finally:
                         self._stopped.set()
 
-    def _cleanup_bcc_wrapper(self) -> None:
+    async def _cleanup_bcc_wrapper(self) -> None:
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             return
-        remove_bcc_wrapper(wrapper_path)
+        await asyncio.to_thread(remove_bcc_wrapper, wrapper_path)
         self._wrapper_path = None
 
     async def wait(self) -> None:

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/attachments.py

@@ -33,13 +33,24 @@ class AttachmentMaterializer:
         root = self._workspace() / "attachments"
         staging = root / ".staging"
         await asyncio.to_thread(staging.mkdir, parents=True, exist_ok=True, mode=0o700)
-        for path in await asyncio.to_thread(lambda: tuple(staging.iterdir())):
-            if path.is_file() and not path.is_symlink():
-                await asyncio.to_thread(path.unlink)
+        staged_files = await asyncio.to_thread(
+            lambda: tuple(
+                path
+                for path in staging.iterdir()
+                if path.is_file() and not path.is_symlink()
+            )
+        )
+        for path in staged_files:
+            await asyncio.to_thread(path.unlink)
         referenced = await self._referenced_paths()
-        for path in await asyncio.to_thread(lambda: tuple(root.iterdir())):
-            if path == staging or not path.is_dir() or path.is_symlink():
-                continue
+        attachment_directories = await asyncio.to_thread(
+            lambda: tuple(
+                path
+                for path in root.iterdir()
+                if path != staging and path.is_dir() and not path.is_symlink()
+            )
+        )
+        for path in attachment_directories:
             try:
                 if UUID(path.name).version != 7:
                     continue
@@ -61,10 +72,7 @@ class AttachmentMaterializer:
         if not name or not kind:
             raise ValueError("attachment name and kind must be non-empty")
         attachment_id = str(uuid7())
-        suffix = Path(name).suffix
-        if not _SAFE_SUFFIX.fullmatch(suffix):
-            guessed = mimetypes.guess_extension(media_type or "") or ".bin"
-            suffix = guessed if _SAFE_SUFFIX.fullmatch(guessed) else ".bin"
+        suffix = await asyncio.to_thread(_attachment_suffix, name, media_type)
         relative = PurePosixPath(
             "attachments", attachment_id, f"content{suffix.lower()}"
         )
@@ -78,8 +86,15 @@ class AttachmentMaterializer:
             )
             current_size = await asyncio.to_thread(self._stored_size, root)
             size = 0
+            descriptor: int | None = None
             try:
-                with temporary.open("xb") as output:
+                descriptor = await asyncio.to_thread(
+                    os.open,
+                    temporary,
+                    os.O_WRONLY | os.O_CREAT | os.O_EXCL,
+                    0o600,
+                )
+                try:
                     if isinstance(source, bytes):
                         size = len(source)
                         if size > self._max_file_bytes:
@@ -88,7 +103,7 @@ class AttachmentMaterializer:
                             )
                         if current_size + size > self._max_workspace_bytes:
                             raise ValueError("attachment workspace quota exceeded")
-                        await asyncio.to_thread(output.write, source)
+                        await asyncio.to_thread(_write_all, descriptor, source)
                     else:
                         async for chunk in source:
                             if not isinstance(chunk, bytes):
@@ -100,9 +115,11 @@ class AttachmentMaterializer:
                                 )
                             if current_size + size > self._max_workspace_bytes:
                                 raise ValueError("attachment workspace quota exceeded")
-                            await asyncio.to_thread(output.write, chunk)
-                    await asyncio.to_thread(output.flush)
-                    await asyncio.to_thread(os.fsync, output.fileno())
+                            await asyncio.to_thread(_write_all, descriptor, chunk)
+                    await asyncio.to_thread(os.fsync, descriptor)
+                finally:
+                    await asyncio.to_thread(os.close, descriptor)
+                    descriptor = None
                 await asyncio.to_thread(
                     destination.parent.mkdir, parents=True, mode=0o700
                 )
@@ -110,7 +127,9 @@ class AttachmentMaterializer:
                 if os.name != "nt":
                     await asyncio.to_thread(destination.chmod, 0o600)
             except BaseException:
-                if temporary.exists():
+                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
         return InboundAttachment(
@@ -151,4 +170,21 @@ class AttachmentMaterializer:
         )
 
 
+def _write_all(descriptor: int, payload: bytes) -> None:
+    view = memoryview(payload)
+    while view:
+        written = os.write(descriptor, view)
+        if written == 0:
+            raise OSError("attachment write made no progress")
+        view = view[written:]
+
+
+def _attachment_suffix(name: str, media_type: str | None) -> str:
+    suffix = Path(name).suffix
+    if _SAFE_SUFFIX.fullmatch(suffix):
+        return suffix
+    guessed = mimetypes.guess_extension(media_type or "") or ".bin"
+    return guessed if _SAFE_SUFFIX.fullmatch(guessed) else ".bin"
+
+
 __all__ = ["AttachmentMaterializer"]

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/command.py

@@ -55,6 +55,16 @@ def serialize_outbound(message: OutboundMessage) -> dict[str, object]:
         "target": message.target,
         "reply_to_message_id": message.reply_to_message_id,
         "body": message.body,
+        "attachments": [
+            {
+                "name": attachment.name,
+                "relative_path": attachment.relative_path,
+                "media_type": attachment.media_type,
+                "size_bytes": attachment.size_bytes,
+                "sha256": attachment.sha256,
+            }
+            for attachment in message.attachments
+        ],
         "state": message.state.value,
         "fresh_check_state": message.fresh_check_state.value,
         "created_at_ms": message.created_at_ms,
@@ -284,6 +294,7 @@ class CommandDispatcher:
             target = request.get("target")
             body = request.get("body")
             command_id = request.get("command_id")
+            attachment_paths = request.get("attachment_paths", [])
             reply_to_message_id = request.get("reply_to_message_id")
             created_at_ms = request.get("created_at_ms", time_ns() // 1_000_000)
             if not isinstance(target, str) or not target:
@@ -296,6 +307,13 @@ class CommandDispatcher:
                 raise CommandDispatchError(
                     "COMMAND_ID_REQUIRED", "command_id must be a non-empty string"
                 )
+            if not isinstance(attachment_paths, list) or not all(
+                isinstance(path, str) and path for path in attachment_paths
+            ):
+                raise CommandDispatchError(
+                    "INVALID_ATTACHMENTS",
+                    "attachment_paths must be a list of non-empty strings",
+                )
             if reply_to_message_id is not None and (
                 not isinstance(reply_to_message_id, str) or not reply_to_message_id
             ):
@@ -317,6 +335,7 @@ class CommandDispatcher:
                 target=target,
                 body=body,
                 created_at_ms=created_at_ms,
+                attachment_paths=tuple(attachment_paths),
                 reply_to_message_id=reply_to_message_id,
             )
             return {

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import tomllib
 from dataclasses import dataclass
 from pathlib import Path
@@ -19,6 +20,7 @@ class NodeConfiguration:
     storage: str | None = None
     audit: str | None = None
     endpoint: str | None = None
+    database_name: str | None = None
     model: str | None = None
     effort: str | None = None
     sandbox_mode: RuntimeSandboxMode = RuntimeSandboxMode.WORKSPACE_WRITE
@@ -36,13 +38,18 @@ def resolve_config_path() -> Path:
     return resolve_data_dir() / CONFIG_FILENAME
 
 
-def load_node_configuration() -> NodeConfiguration:
-    path = resolve_config_path()
+def load_node_configuration(path: Path | None = None) -> NodeConfiguration:
+    path = path or resolve_config_path()
     try:
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        try:
+            descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:
+            pass
+        else:
+            os.close(descriptor)
         with path.open("rb") as config_file:
             payload = tomllib.load(config_file)
-    except FileNotFoundError:
-        return NodeConfiguration()
     except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
         raise ConfigurationError(f"cannot read {path}: {error}") from error
 
@@ -80,6 +87,7 @@ def load_node_configuration() -> NodeConfiguration:
         storage=_optional_text(node.get("storage"), "node.storage"),
         audit=_optional_text(node.get("audit"), "node.audit"),
         endpoint=_optional_text(node.get("endpoint"), "node.endpoint"),
+        database_name=_optional_text(node.get("database_name"), "node.database_name"),
         model=_optional_text(runtime.get("model"), "runtime.model"),
         effort=_optional_text(runtime.get("effort"), "runtime.effort"),
         sandbox_mode=parsed_sandbox_mode,

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/registry.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
+from functools import partial
 from importlib.metadata import EntryPoint, entry_points
 from typing import Any, cast
 
@@ -46,11 +47,18 @@ class AdapterRegistry:
         runtime: str,
         storage: str = "sqlite",
         audit: str = "logging",
+        storage_options: Mapping[str, object] | None = None,
     ) -> AdapterFactories:
         control = self._load_optional(
             CONTROL_ENTRY_POINT_GROUP,
             f"{channel}+{runtime}+{storage}",
         )
+        storage_factory = cast(
+            Callable[[Mapping[str, object]], IStorage] | StorageFactory,
+            self._load(STORAGE_ENTRY_POINT_GROUP, storage),
+        )
+        if storage_options:
+            storage_factory = partial(storage_factory, dict(storage_options))
         return AdapterFactories(
             channel=cast(
                 ChannelFactory,
@@ -60,10 +68,7 @@ class AdapterRegistry:
                 RuntimeFactory,
                 self._load(RUNTIME_ENTRY_POINT_GROUP, runtime),
             ),
-            storage=cast(
-                StorageFactory,
-                self._load(STORAGE_ENTRY_POINT_GROUP, storage),
-            ),
+            storage=cast(StorageFactory, storage_factory),
             audit=cast(
                 AuditFactory,
                 self._load(AUDIT_ENTRY_POINT_GROUP, audit),

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/transport.py

@@ -84,21 +84,23 @@ class LocalCommandServer:
 
         path = self._endpoint_path
         if path is None:
-            path = (
-                Path(tempfile.gettempdir())
-                / f"bcn-{os.getpid()}-{secrets.token_hex(6)}.sock"
+            path = await asyncio.to_thread(
+                lambda: (
+                    Path(tempfile.gettempdir())
+                    / f"bcn-{os.getpid()}-{secrets.token_hex(6)}.sock"
+                )
             )
         path = path.expanduser()
-        path.parent.mkdir(parents=True, exist_ok=True)
-        if path.exists():
+        await asyncio.to_thread(path.parent.mkdir, parents=True, exist_ok=True)
+        if await asyncio.to_thread(path.exists):
             raise FileExistsError(f"local command endpoint already exists: {path}")
         self._server = await asyncio.start_unix_server(
             self._handle_client,
             path=str(path),
         )
-        os.chmod(path, 0o600)
+        await asyncio.to_thread(os.chmod, path, 0o600)
         self._unix_path = path
-        path_stat = path.stat()
+        path_stat = await asyncio.to_thread(path.stat)
         self._unix_identity = (path_stat.st_dev, path_stat.st_ino)
         self._endpoint = f"unix://{path}"
 
@@ -122,10 +124,14 @@ class LocalCommandServer:
         self._unix_path = None
         identity = self._unix_identity
         self._unix_identity = None
-        if path is not None and identity is not None and path.exists():
-            path_stat = path.stat()
+        if (
+            path is not None
+            and identity is not None
+            and await asyncio.to_thread(path.exists)
+        ):
+            path_stat = await asyncio.to_thread(path.stat)
             if (path_stat.st_dev, path_stat.st_ino) == identity:
-                path.unlink()
+                await asyncio.to_thread(path.unlink)
 
     async def _handle_client(
         self,

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/app/windows_pipe.py

@@ -12,6 +12,8 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import urlsplit
 
+from bazaar_compute_node.core.paths import resolve_data_dir
+
 RequestHandler = Callable[[Mapping[str, object]], Awaitable[Mapping[str, object]]]
 
 _ERROR_ALREADY_EXISTS = 183
@@ -122,8 +124,8 @@ def _is_invalid_handle(handle: Any) -> bool:
 
 
 def _pipe_name(endpoint_path: Path | None) -> str:
-    path = endpoint_path or (Path.home() / ".bcn" / "bcn.sock")
-    identity = str(path.expanduser().resolve(strict=False)).casefold()
+    path = endpoint_path or (resolve_data_dir() / "bcn.sock")
+    identity = str(path.expanduser().absolute()).casefold()
     digest = hashlib.sha256(identity.encode("utf-8")).hexdigest()[:32]
     return f"bcn-{digest}"
 

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/bcc.py

@@ -5,6 +5,7 @@ import asyncio
 import os
 import sys
 from collections.abc import Mapping, Sequence
+from pathlib import Path
 from typing import NoReturn
 from uuid import uuid7
 
@@ -46,6 +47,7 @@ def build_parser() -> argparse.ArgumentParser:
     send_parser = message_subparsers.add_parser("send")
     send_parser.add_argument("--target", required=True)
     send_parser.add_argument("--reply-to")
+    send_parser.add_argument("--attachment", action="append", default=[])
 
     thread_parser = subparsers.add_parser("thread")
     thread_subparsers = thread_parser.add_subparsers(dest="command", required=True)
@@ -100,6 +102,9 @@ async def _request(
         request["body"] = body if body is not None else ""
         request["command_id"] = f"bcc-{uuid7().hex}"
         request["reply_to_message_id"] = args.reply_to
+        request["attachment_paths"] = await asyncio.to_thread(
+            lambda: [str(Path(path).absolute()) for path in args.attachment]
+        )
     elif args.command == "unfollow":
         request["target"] = args.target
 

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/cli.py

@@ -66,6 +66,16 @@ def build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument("--storage")
     parser.add_argument("--audit")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        help="Configuration file path; defaults to the node data directory.",
+    )
+    parser.add_argument(
+        "--database-name",
+        type=_database_name,
+        help="SQLite database filename under the node data directory.",
+    )
     parser.add_argument(
         "--endpoint",
         type=Path,
@@ -85,6 +95,14 @@ def _non_empty_option(value: str) -> str:
     return value
 
 
+def _database_name(value: str) -> str:
+    if not value or value in {".", ".."} or "/" in value or "\\" in value:
+        raise argparse.ArgumentTypeError(
+            "database name must be a single non-empty path component"
+        )
+    return value
+
+
 def _endpoint_path(args: argparse.Namespace, data_dir: Path) -> Path:
     return (args.endpoint or data_dir / "bcn.sock").expanduser()
 
@@ -107,6 +125,9 @@ def _load_factories(
             runtime=args.runtime,
             storage=args.storage,
             audit=args.audit,
+            storage_options={"database_name": args.database_name}
+            if args.storage == "sqlite" and args.database_name is not None
+            else None,
         )
     except ProviderLoadError as error:
         parser.error(str(error))
@@ -128,7 +149,7 @@ def _apply_runtime_configuration(
     parser: argparse.ArgumentParser,
 ) -> None:
     try:
-        configuration = load_node_configuration()
+        configuration = load_node_configuration(args.config)
     except ConfigurationError as error:
         parser.error(str(error))
     for name in (
@@ -145,6 +166,8 @@ def _apply_runtime_configuration(
             setattr(args, name, getattr(configuration, name))
     if args.endpoint is None and configuration.endpoint is not None:
         args.endpoint = Path(configuration.endpoint).expanduser()
+    if args.database_name is None:
+        args.database_name = configuration.database_name
     if args.storage is None:
         args.storage = DEFAULT_STORAGE
     if args.audit is None:
@@ -157,7 +180,7 @@ def _apply_runtime_configuration(
 
 
 async def _run_node(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
-    factories = _load_factories(args, parser)
+    factories = await asyncio.to_thread(_load_factories, args, parser)
 
     data_dir = resolve_data_dir()
     node = NodeApplication(
@@ -198,6 +221,10 @@ def _daemon_command(args: argparse.Namespace, data_dir: Path) -> list[str]:
         "--endpoint",
         str(_endpoint_path(args, data_dir)),
     ]
+    if args.config is not None:
+        command.extend(("--config", str(args.config)))
+    if args.database_name is not None:
+        command.extend(("--database-name", args.database_name))
     for name in ("model", "effort", "sandbox_mode"):
         value = getattr(args, name)
         if value is not None:
@@ -284,14 +311,14 @@ async def _start_daemon(
     args: argparse.Namespace,
     parser: argparse.ArgumentParser,
 ) -> int:
-    _load_factories(args, parser)
-    data_dir = resolve_data_dir()
-    data_dir.mkdir(parents=True, exist_ok=True)
+    await asyncio.to_thread(_load_factories, args, parser)
+    data_dir = await asyncio.to_thread(resolve_data_dir)
+    await asyncio.to_thread(data_dir.mkdir, parents=True, exist_ok=True)
     endpoint_path = _endpoint_path(args, data_dir)
     endpoint = local_endpoint_for_path(endpoint_path)
     if os.name == "nt" and await _endpoint_is_reachable(endpoint, timeout=0.5):
         parser.error("bcn is already running")
-    if os.name != "nt" and endpoint_path.exists():
+    if os.name != "nt" and await asyncio.to_thread(endpoint_path.exists):
         parser.error(f"bcn endpoint already exists: {endpoint_path}")
 
     log_path = data_dir / "bcn.log"
@@ -316,7 +343,7 @@ async def _stop_daemon(
     args: argparse.Namespace,
     parser: argparse.ArgumentParser,
 ) -> int:
-    data_dir = resolve_data_dir()
+    data_dir = await asyncio.to_thread(resolve_data_dir)
     endpoint_path = _endpoint_path(args, data_dir)
     endpoint = local_endpoint_for_path(endpoint_path)
     if not await _endpoint_is_reachable(endpoint, timeout=0.5):
@@ -354,10 +381,8 @@ async def _restart_daemon(
 
 
 async def async_main(argv: Sequence[str] | None = None) -> int:
-    parser = build_parser()
-    args = parser.parse_args(argv)
+    parser, args = await asyncio.to_thread(_prepare_cli_arguments, argv)
     command = args.command
-    _apply_runtime_configuration(args, parser)
     if command is None:
         if args.channel is None and args.runtime is None:
             parser.print_help()
@@ -374,6 +399,17 @@ async def async_main(argv: Sequence[str] | None = None) -> int:
     parser.error(f"unsupported command: {command}")
 
 
+def _prepare_cli_arguments(
+    argv: Sequence[str] | None,
+) -> tuple[argparse.ArgumentParser, argparse.Namespace]:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.config is not None:
+        args.config = args.config.expanduser().resolve()
+    _apply_runtime_configuration(args, parser)
+    return parser, args
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     return asyncio.run(async_main(argv))
 

{bazaar_compute_node-0.1.4 → bazaar_compute_node-0.1.6}/src/bazaar_compute_node/contrib/codex_app_server/__init__.py

@@ -11,10 +11,12 @@ from .client import (
     build_thread_start_params,
     build_turn_interrupt_params,
     build_turn_start_params,
+    build_turn_steer_params,
     parse_error_notification,
     parse_thread_response,
     parse_turn_notification,
     parse_turn_response,
+    parse_turn_steer_response,
 )
 from .events import CodexTurnEventStream
 from .process import (
@@ -56,8 +58,10 @@ __all__ = [
     "build_thread_start_params",
     "build_turn_interrupt_params",
     "build_turn_start_params",
+    "build_turn_steer_params",
     "parse_error_notification",
     "parse_thread_response",
     "parse_turn_notification",
     "parse_turn_response",
+    "parse_turn_steer_response",
 ]