bazaar-compute-node 0.1.5__tar.gz → 0.1.7__tar.gz

{bazaar_compute_node-0.1.5 → bazaar_compute_node-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.5
+Version: 0.1.7
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -24,6 +24,7 @@ Harness 工具。
 - **自由组合**：根据使用场景分别选择 Channel 与 Runtime，并可独立替换和扩展。
 - **持续会话**：每个用户和对话拥有独立上下文，节点重启后仍可继续之前的任务。
 - **真实工作区**：Runtime 可以在独立工作区中分析、创建和修改文件，而不局限于文本回答。
+- **双向附件**：Channel 收到的媒体会进入会话工作区，Runtime 也可以通过 Channel 交付工作区中的文件。
 - **可靠交付**：自动处理长结果的分批发送并记录交付状态，避免任务结果静默丢失。
 - **安全边界**：复用所选 Harness 的权限机制，按任务需要控制文件与网络访问。
 - **跨平台运行**：支持 Linux、macOS 和 Windows，并以后台进程长期运行。
@@ -57,7 +58,6 @@ bcn 将沿着可组合的 Channel、Runtime 与节点通用能力继续扩展。
 
 ### 节点能力
 
-- **附件发送**：让 Agent 可以通过当前 Channel 交付生成的文件；
 - **定时任务**：创建一次性或周期性任务，由节点按计划自动执行并返回结果。
 
 ## 安装
@@ -91,7 +91,8 @@ Channel 即可。
 ### WeCom
 
 WeCom Channel 对接企业微信智能机器人，支持单聊、群聊、文本与媒体输入，以及 Markdown
-长消息分批返回。群聊中需要 @机器人，确保消息能够进入节点。
+长消息分批和附件返回。收到的媒体会以工作区相对路径提供给 Runtime；Runtime 可以把工作区内的
+普通文件作为附件发送，附件路径不能包含符号链接。群聊中需要 @机器人，确保消息能够进入节点。
 
 在 `~/.bcn/config.toml` 中配置 Bot ID：
 
@@ -128,9 +129,12 @@ Runtime 即可。
 [runtime]
 sandbox_mode = "workspace-write"
 network_access = true
+idle_timeout = 0
 ```
 
 如需覆盖 Codex 的默认模型或推理强度，可以在 `[runtime]` 中增加 `model` 和 `effort`。
+`idle_timeout` 以秒为单位并支持小数；默认值 `0` 与所有 `<= 0` 的值表示 runtime session
+常驻。设置为正值后，每条新收到的消息都会刷新空闲回收期限。
 除非你明确需要使用运行用户已有的主机权限，否则不要将 `sandbox_mode` 改为
 `danger-full-access`。
 
@@ -167,7 +171,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.5 → bazaar_compute_node-0.1.7}/README.md

@@ -11,6 +11,7 @@ Harness 工具。
 - **自由组合**：根据使用场景分别选择 Channel 与 Runtime，并可独立替换和扩展。
 - **持续会话**：每个用户和对话拥有独立上下文，节点重启后仍可继续之前的任务。
 - **真实工作区**：Runtime 可以在独立工作区中分析、创建和修改文件，而不局限于文本回答。
+- **双向附件**：Channel 收到的媒体会进入会话工作区，Runtime 也可以通过 Channel 交付工作区中的文件。
 - **可靠交付**：自动处理长结果的分批发送并记录交付状态，避免任务结果静默丢失。
 - **安全边界**：复用所选 Harness 的权限机制，按任务需要控制文件与网络访问。
 - **跨平台运行**：支持 Linux、macOS 和 Windows，并以后台进程长期运行。
@@ -44,7 +45,6 @@ bcn 将沿着可组合的 Channel、Runtime 与节点通用能力继续扩展。
 
 ### 节点能力
 
-- **附件发送**：让 Agent 可以通过当前 Channel 交付生成的文件；
 - **定时任务**：创建一次性或周期性任务，由节点按计划自动执行并返回结果。
 
 ## 安装
@@ -78,7 +78,8 @@ Channel 即可。
 ### WeCom
 
 WeCom Channel 对接企业微信智能机器人，支持单聊、群聊、文本与媒体输入，以及 Markdown
-长消息分批返回。群聊中需要 @机器人，确保消息能够进入节点。
+长消息分批和附件返回。收到的媒体会以工作区相对路径提供给 Runtime；Runtime 可以把工作区内的
+普通文件作为附件发送，附件路径不能包含符号链接。群聊中需要 @机器人，确保消息能够进入节点。
 
 在 `~/.bcn/config.toml` 中配置 Bot ID：
 
@@ -115,9 +116,12 @@ Runtime 即可。
 [runtime]
 sandbox_mode = "workspace-write"
 network_access = true
+idle_timeout = 0
 ```
 
 如需覆盖 Codex 的默认模型或推理强度，可以在 `[runtime]` 中增加 `model` 和 `effort`。
+`idle_timeout` 以秒为单位并支持小数；默认值 `0` 与所有 `<= 0` 的值表示 runtime session
+常驻。设置为正值后，每条新收到的消息都会刷新空闲回收期限。
 除非你明确需要使用运行用户已有的主机权限，否则不要将 `sandbox_mode` 改为
 `danger-full-access`。
 
@@ -154,7 +158,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.5 → bazaar_compute_node-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.5"
+version = "0.1.7"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -19,7 +19,7 @@ Repository = "https://github.com/yuchanns/bazaar-compute-node"
 bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
-codex = "bazaar_compute_node.contrib.codex_app_server.plugin:create_runtime"
+codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:create_channel"
@@ -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.5 → bazaar_compute_node-0.1.7}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.5"
+version = "0.1.7"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -19,7 +19,7 @@ Repository = "https://github.com/yuchanns/bazaar-compute-node"
 bcn = "bazaar_compute_node.cli:main"
 
 [project.entry-points."bazaar_compute_node.runtimes"]
-codex = "bazaar_compute_node.contrib.codex_app_server.plugin:create_runtime"
+codex = "bazaar_compute_node.contrib.codex.plugin:create_runtime"
 
 [project.entry-points."bazaar_compute_node.channels"]
 wecom = "bazaar_compute_node.contrib.wecom.plugin:create_channel"
@@ -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.5 → bazaar_compute_node-0.1.7}/src/bazaar_compute_node/app/application.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import hmac
+import math
 import os
 import re
 import secrets
@@ -17,6 +18,7 @@ from ..core.orchestration import SessionOrchestrator
 from ..core.paths import resolve_data_dir, resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext, RuntimeSandboxMode
 from ..core.storage import IStorage, NodeIdentity
+from ..core.timerwheel import TimerWheel
 from .attachments import AttachmentMaterializer
 from .command import (
     CommandDispatcher,
@@ -64,6 +66,7 @@ class NodeApplication:
         runtime_options: Mapping[str, str] | None = None,
         runtime_sandbox_mode: RuntimeSandboxMode = RuntimeSandboxMode.WORKSPACE_WRITE,
         runtime_network_access: bool = True,
+        runtime_idle_timeout_seconds: float = 0,
         channel_options: Mapping[str, object] | None = None,
         runtime_environment_include: Sequence[str] = (),
         timeout_budget: TimeoutBudget | None = None,
@@ -81,8 +84,7 @@ class NodeApplication:
         self.command_log: list[CommandRecord] = []
         self._wrapper_path: Path | None = None
         self._identity: NodeIdentity | None = None
-        self._session_capabilities: dict[str, str] = {}
-        self._runtime_session_ids: dict[str, str] = {}
+        self._session_capabilities: dict[str, tuple[str, str]] = {}
         self._started = False
         self._stopped = asyncio.Event()
         self._runtime_environment_include = tuple(runtime_environment_include)
@@ -106,6 +108,23 @@ class NodeApplication:
             startup_timeout_seconds=self.timeout_budget.startup_seconds,
         )
         self.runtime: IRuntime = factories.runtime(self._runtime_context)
+        if (
+            isinstance(runtime_idle_timeout_seconds, bool)
+            or not isinstance(runtime_idle_timeout_seconds, int | float)
+            or not math.isfinite(runtime_idle_timeout_seconds)
+        ):
+            raise ValueError("runtime_idle_timeout_seconds must be a finite number")
+        self.timer_wheel = TimerWheel()
+        if (
+            runtime_idle_timeout_seconds > 0
+            and runtime_idle_timeout_seconds * 1_000 > self.timer_wheel.maximum_delay_ms
+        ):
+            raise ValueError("runtime_idle_timeout_seconds exceeds the timer horizon")
+        runtime_idle_timeout_ms = (
+            math.ceil(runtime_idle_timeout_seconds * 1_000)
+            if runtime_idle_timeout_seconds > 0
+            else 0
+        )
         self.orchestrator = SessionOrchestrator(
             node_id=node_id,
             workspace_id=workspace_id,
@@ -114,6 +133,9 @@ class NodeApplication:
             storage=self.storage,
             audit=self.audit,
             timeout_budget=self.timeout_budget,
+            timer_wheel=self.timer_wheel,
+            runtime_idle_timeout_ms=runtime_idle_timeout_ms,
+            workspace=self._workspace_path,
             on_node_initialized=self._ensure_workspace,
         )
         self.command_service = self.orchestrator.command_service
@@ -139,17 +161,23 @@ 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.timer_wheel.start()
             await self.command_server.start()
             await self.orchestrator.start(
                 timeout=self.timeout_budget.startup_seconds,
             )
         except BaseException:
-            await self.stop()
+            try:
+                await self.stop()
+            finally:
+                await self.timer_wheel.close()
             raise
         self._started = True
         self._stopped.clear()
@@ -165,7 +193,10 @@ class NodeApplication:
                 try:
                     await self.command_server.stop()
                 finally:
-                    self._cleanup_bcc_wrapper()
+                    try:
+                        await self._cleanup_bcc_wrapper()
+                    finally:
+                        await self.timer_wheel.close()
             return
         self._started = False
         self.command_dispatcher.stop_accepting()
@@ -183,15 +214,18 @@ class NodeApplication:
                     await self.command_server.stop()
                 finally:
                     try:
-                        self._cleanup_bcc_wrapper()
+                        await self._cleanup_bcc_wrapper()
                     finally:
-                        self._stopped.set()
+                        try:
+                            await self.timer_wheel.close()
+                        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:
@@ -275,18 +309,19 @@ class NodeApplication:
                     "SESSION_NOT_FOUND",
                     f"unknown bcn session: {session_id}",
                 )
-            runtime_session = await transaction.find_runtime_session(session_id)
-        if runtime_session is None or runtime_session_id != (runtime_session.id):
+        runtime_session = self.orchestrator.runtime_session(session_id)
+        if runtime_session is None or runtime_session_id != runtime_session.id:
             raise CommandDispatchError(
                 "SESSION_BINDING_FAILED",
                 "runtime session binding is invalid",
             )
-        expected_capability = self._session_capabilities.get(session_id)
+        capability_binding = self._session_capabilities.get(session_id)
         if (
-            expected_capability is None
+            capability_binding is None
+            or capability_binding[0] != runtime_session.id
             or not isinstance(session_capability, str)
             or not hmac.compare_digest(
-                session_capability.encode(), expected_capability.encode()
+                session_capability.encode(), capability_binding[1].encode()
             )
         ):
             raise CommandDispatchError(
@@ -295,7 +330,9 @@ class NodeApplication:
             )
 
     def _runtime_environment(self, session: RuntimeSession) -> Mapping[str, str]:
-        self._runtime_session_ids[session.bcn_session_id] = session.id
+        runtime_session = self.orchestrator.runtime_session(session.bcn_session_id)
+        if runtime_session is None or runtime_session.id != session.id:
+            raise RuntimeError("runtime session is not the current live binding")
         return self._build_command_environment(
             session.bcn_session_id,
             session.id,
@@ -313,10 +350,11 @@ class NodeApplication:
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
-        session_capability = self._session_capabilities.setdefault(
-            session_id,
-            secrets.token_urlsafe(32),
-        )
+        capability_binding = self._session_capabilities.get(session_id)
+        if capability_binding is None or capability_binding[0] != runtime_session_id:
+            capability_binding = (runtime_session_id, secrets.token_urlsafe(32))
+            self._session_capabilities[session_id] = capability_binding
+        session_capability = capability_binding[1]
         wrapper_directory = str(wrapper_path.parent)
         allowed = set(_PLATFORM_ENVIRONMENT)
         for name in self.runtime.environment_variable_names():
@@ -365,13 +403,12 @@ class NodeApplication:
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
         self.command_log.append((session_id, tuple(arguments)))
-        runtime_session_id = self._runtime_session_ids.get(
-            session_id,
-            f"runtime-{session_id}",
-        )
+        runtime_session = self.orchestrator.runtime_session(session_id)
+        if runtime_session is None:
+            raise RuntimeError("runtime session is not live")
         environment = self._build_command_environment(
             session_id,
-            runtime_session_id,
+            runtime_session.id,
         )
         process = await asyncio.create_subprocess_exec(
             str(wrapper_path),

{bazaar_compute_node-0.1.5 → bazaar_compute_node-0.1.7}/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.5 → bazaar_compute_node-0.1.7}/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.5 → bazaar_compute_node-0.1.7}/src/bazaar_compute_node/app/config.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import math
+import os
 import tomllib
 from dataclasses import dataclass
 from pathlib import Path
@@ -19,10 +21,12 @@ 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
     network_access: bool = True
+    runtime_idle_timeout_seconds: float = 0
     runtime_env_include: tuple[str, ...] = ()
     wecom_bot_id: str | None = None
     wecom_websocket_url: str | None = None
@@ -36,13 +40,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
 
@@ -74,16 +83,25 @@ def load_node_configuration() -> NodeConfiguration:
     network_access = runtime.get("network_access", True)
     if not isinstance(network_access, bool):
         raise ConfigurationError("runtime.network_access must be a boolean")
+    idle_timeout = runtime.get("idle_timeout", 0)
+    if (
+        isinstance(idle_timeout, bool)
+        or not isinstance(idle_timeout, int | float)
+        or not math.isfinite(idle_timeout)
+    ):
+        raise ConfigurationError("runtime.idle_timeout must be a finite number")
     return NodeConfiguration(
         channel=_optional_text(node.get("channel"), "node.channel"),
         runtime=_optional_text(node.get("runtime"), "node.runtime"),
         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,
         network_access=network_access,
+        runtime_idle_timeout_seconds=float(idle_timeout),
         runtime_env_include=_text_list(
             runtime_env.get("include", []), "runtime.env.include"
         ),

{bazaar_compute_node-0.1.5 → bazaar_compute_node-0.1.7}/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),