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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.6
+Version: 0.1.8
 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`。
 

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.8}/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`。
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.6"
+version = "0.1.8"
 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"

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

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.6"
+version = "0.1.8"
 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"

{bazaar_compute_node-0.1.6 → bazaar_compute_node-0.1.8}/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
@@ -10,19 +11,20 @@ from collections.abc import Mapping, Sequence
 from pathlib import Path
 
 from ..core.channel import ChannelContext, IChannel
+from ..core.concurrency import SessionLockRegistry
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import RuntimeSession
 from ..core.observability import IAudit
-from ..core.orchestration import SessionOrchestrator
+from ..core.orchestration import ReminderScheduler, SessionOrchestrator
+from ..core.orchestration.reminder_command import ReminderCommandService
 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,
-    CommandDispatchError,
-)
+from .command import CommandDispatchError
 from .registry import AdapterFactories
+from .reminder_dispatch import CommandDispatcher
 from .transport import LocalCommandServer
 from .wrapper import install_bcc_wrapper, remove_bcc_wrapper
 
@@ -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,8 @@ 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._concurrency = SessionLockRegistry()
         self._started = False
         self._stopped = asyncio.Event()
         self._runtime_environment_include = tuple(runtime_environment_include)
@@ -106,6 +109,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,15 +134,30 @@ 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,
+            concurrency=self._concurrency,
             on_node_initialized=self._ensure_workspace,
         )
+        self.reminder_scheduler = ReminderScheduler(
+            storage=self.storage,
+            timer_wheel=self.timer_wheel,
+            concurrency=self._concurrency,
+            publish_wake=self.orchestrator.publish_reminder_wake,
+        )
+        self.reminder_service = ReminderCommandService(
+            storage=self.storage,
+            concurrency=self._concurrency,
+            poke=self.reminder_scheduler.poke,
+        )
         self.command_service = self.orchestrator.command_service
         control_handler = None
         if factories.control is not None:
             control_handler = factories.control(self._adapter_context())
         self.command_dispatcher = CommandDispatcher(
             self.command_service,
+            reminder_service=self.reminder_service,
             timeout_budget=self.timeout_budget,
             control_handler=self._handle_control,
             session_binding_validator=self._validate_session_binding,
@@ -147,28 +182,43 @@ class NodeApplication:
             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,
             )
+            self._started = True
+            await self.reminder_scheduler.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()
         self.command_dispatcher.start_accepting()
 
     async def stop(self) -> None:
         if not self._started:
             try:
-                await self.command_dispatcher.drain(
+                await self.reminder_scheduler.stop(
                     timeout=self.timeout_budget.shutdown_seconds,
                 )
             finally:
                 try:
-                    await self.command_server.stop()
+                    await self.command_dispatcher.drain(
+                        timeout=self.timeout_budget.shutdown_seconds,
+                    )
                 finally:
-                    await self._cleanup_bcc_wrapper()
+                    try:
+                        await self.command_server.stop()
+                    finally:
+                        try:
+                            await self._cleanup_bcc_wrapper()
+                        finally:
+                            await self.timer_wheel.close()
             return
         self._started = False
         self.command_dispatcher.stop_accepting()
@@ -178,17 +228,25 @@ class NodeApplication:
             )
         finally:
             try:
-                await self.orchestrator.stop(
+                await self.reminder_scheduler.stop(
                     timeout=self.timeout_budget.shutdown_seconds,
                 )
             finally:
                 try:
-                    await self.command_server.stop()
+                    await self.orchestrator.stop(
+                        timeout=self.timeout_budget.shutdown_seconds,
+                    )
                 finally:
                     try:
-                        await self._cleanup_bcc_wrapper()
+                        await self.command_server.stop()
                     finally:
-                        self._stopped.set()
+                        try:
+                            await self._cleanup_bcc_wrapper()
+                        finally:
+                            try:
+                                await self.timer_wheel.close()
+                            finally:
+                                self._stopped.set()
 
     async def _cleanup_bcc_wrapper(self) -> None:
         wrapper_path = self._wrapper_path
@@ -278,18 +336,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(
@@ -298,7 +357,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,
@@ -316,10 +377,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():
@@ -368,13 +430,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.6 → bazaar_compute_node-0.1.8}/src/bazaar_compute_node/app/command.py

@@ -100,7 +100,7 @@ SessionBindingValidator = Callable[[str, Mapping[str, object]], Awaitable[None]]
 
 
 class CommandDispatcher:
-    """Translate local JSON requests into core command results."""
+    """Translate resource-scoped local JSON requests into core command results."""
 
     def __init__(
         self,
@@ -222,20 +222,40 @@ class CommandDispatcher:
     async def _dispatch_command(
         self, request: Mapping[str, object]
     ) -> Mapping[str, object]:
-        session_id = request.get("session_id")
-        if not isinstance(session_id, str) or not session_id:
+        resource = request.get("resource")
+        if not isinstance(resource, str) or not resource:
             raise CommandDispatchError(
-                "SESSION_REQUIRED", "session_id must be a non-empty string"
+                "RESOURCE_REQUIRED", "resource must be a non-empty string"
             )
         command = request.get("command")
         if not isinstance(command, str) or not command:
             raise CommandDispatchError(
                 "COMMAND_REQUIRED", "command must be a non-empty string"
             )
+        if resource == "message":
+            if command not in {"check", "read", "send"}:
+                raise CommandDispatchError(
+                    "UNKNOWN_COMMAND", f"unsupported message command: {command}"
+                )
+        elif resource == "thread":
+            if command != "unfollow":
+                raise CommandDispatchError(
+                    "UNKNOWN_COMMAND", f"unsupported thread command: {command}"
+                )
+        else:
+            raise CommandDispatchError(
+                "UNKNOWN_RESOURCE", f"unsupported command resource: {resource}"
+            )
+
+        session_id = request.get("session_id")
+        if not isinstance(session_id, str) or not session_id:
+            raise CommandDispatchError(
+                "SESSION_REQUIRED", "session_id must be a non-empty string"
+            )
         if self._session_binding_validator is not None:
             await self._session_binding_validator(session_id, request)
 
-        if command == "check":
+        if resource == "message" and command == "check":
             result = await self._service.check(session_id)
             return {
                 "ok": True,
@@ -252,7 +272,7 @@ class CommandDispatcher:
                 },
             }
 
-        if command == "read":
+        if resource == "message" and command == "read":
             target = request.get("target")
             if not isinstance(target, str) or not target:
                 raise CommandDispatchError(
@@ -290,7 +310,7 @@ class CommandDispatcher:
                 },
             }
 
-        if command == "send":
+        if resource == "message" and command == "send":
             target = request.get("target")
             body = request.get("body")
             command_id = request.get("command_id")
@@ -343,7 +363,7 @@ class CommandDispatcher:
                 "result": {"outbound": serialize_outbound(result)},
             }
 
-        if command == "unfollow":
+        if resource == "thread" and command == "unfollow":
             target = request.get("target")
             if not isinstance(target, str) or not target:
                 raise CommandDispatchError(
@@ -352,7 +372,7 @@ class CommandDispatcher:
             changed = await self._service.unfollow(session_id, target=target)
             return {"ok": True, "result": {"changed": changed}}
 
-        raise CommandDispatchError("UNKNOWN_COMMAND", f"unsupported command: {command}")
+        raise AssertionError("validated command route has no handler")
 
 
 def format_message_time(timestamp_ms: int) -> str:

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import os
 import tomllib
 from dataclasses import dataclass
@@ -25,6 +26,7 @@ class NodeConfiguration:
     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
@@ -81,6 +83,13 @@ def load_node_configuration(path: Path | None = None) -> 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"),
@@ -92,6 +101,7 @@ def load_node_configuration(path: Path | None = None) -> NodeConfiguration:
         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"
         ),