bazaar-compute-node 0.1.3__py3-none-any.whl

bazaar_compute_node/cli.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import subprocess
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from . import __version__
+from .app.application import NodeApplication
+from .app.config import ConfigurationError, load_node_configuration
+from .app.registry import AdapterFactories, AdapterRegistry, ProviderLoadError
+from .app.transport import LocalCommandClient, local_endpoint_for_path
+from .core.paths import resolve_data_dir
+from .core.runtime import RuntimeSandboxMode
+
+DEFAULT_AUDIT = "logging"
+DEFAULT_STORAGE = "sqlite"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    default_data_dir = resolve_data_dir()
+    parser = argparse.ArgumentParser(
+        prog="bcn",
+        description=(
+            "Runtime-agnostic computer node daemon for agents and channels. "
+            f"Persistent node root: {default_data_dir}."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=("start", "stop", "restart", "run"),
+        help="Daemon command; providing adapter options without a command means start.",
+    )
+    parser.add_argument("--channel")
+    parser.add_argument("--runtime")
+    parser.add_argument(
+        "--model",
+        type=_non_empty_option,
+        help="Optional model override passed to the selected runtime.",
+    )
+    parser.add_argument(
+        "--effort",
+        type=_non_empty_option,
+        help="Optional reasoning effort passed to the selected runtime.",
+    )
+    parser.add_argument(
+        "--sandbox-mode",
+        type=RuntimeSandboxMode,
+        choices=tuple(RuntimeSandboxMode),
+        help="Filesystem sandbox mode applied to runtime turns.",
+    )
+    parser.add_argument(
+        "--network-access",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Allow runtime commands to access the network.",
+    )
+    parser.add_argument("--storage")
+    parser.add_argument("--audit")
+    parser.add_argument(
+        "--endpoint",
+        type=Path,
+        help="Local command endpoint path on Unix; Windows derives a named pipe.",
+    )
+    parser.add_argument(
+        "--foreground",
+        action="store_true",
+        help="Run the selected node in the current process instead of daemonizing.",
+    )
+    return parser
+
+
+def _non_empty_option(value: str) -> str:
+    if not value:
+        raise argparse.ArgumentTypeError("option value must be non-empty")
+    return value
+
+
+def _endpoint_path(args: argparse.Namespace, data_dir: Path) -> Path:
+    return (args.endpoint or data_dir / "bcn.sock").expanduser()
+
+
+def _require_adapters(
+    parser: argparse.ArgumentParser, args: argparse.Namespace
+) -> None:
+    if args.channel is None or args.runtime is None:
+        parser.error("--channel and --runtime must be provided together")
+
+
+def _load_factories(
+    args: argparse.Namespace,
+    parser: argparse.ArgumentParser,
+) -> AdapterFactories:
+    _require_adapters(parser, args)
+    try:
+        return AdapterRegistry().load(
+            channel=args.channel,
+            runtime=args.runtime,
+            storage=args.storage,
+            audit=args.audit,
+        )
+    except ProviderLoadError as error:
+        parser.error(str(error))
+
+
+def _runtime_options(args: argparse.Namespace) -> dict[str, str]:
+    return {
+        name: value
+        for name, value in (
+            ("model", args.model),
+            ("effort", args.effort),
+        )
+        if value is not None
+    }
+
+
+def _apply_runtime_configuration(
+    args: argparse.Namespace,
+    parser: argparse.ArgumentParser,
+) -> None:
+    try:
+        configuration = load_node_configuration()
+    except ConfigurationError as error:
+        parser.error(str(error))
+    for name in (
+        "channel",
+        "runtime",
+        "storage",
+        "audit",
+        "model",
+        "effort",
+        "sandbox_mode",
+        "network_access",
+    ):
+        if getattr(args, name) is None:
+            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.storage is None:
+        args.storage = DEFAULT_STORAGE
+    if args.audit is None:
+        args.audit = DEFAULT_AUDIT
+    args.runtime_env_include = configuration.runtime_env_include
+    args.channel_options = {
+        "bot_id": configuration.wecom_bot_id,
+        "websocket_url": configuration.wecom_websocket_url,
+    }
+
+
+async def _run_node(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
+    factories = _load_factories(args, parser)
+
+    data_dir = resolve_data_dir()
+    node = NodeApplication(
+        factories=factories,
+        endpoint_path=_endpoint_path(args, data_dir),
+        runtime_options=_runtime_options(args),
+        runtime_sandbox_mode=args.sandbox_mode,
+        runtime_network_access=args.network_access,
+        channel_options=args.channel_options if args.channel == "wecom" else {},
+        runtime_environment_include=args.runtime_env_include,
+    )
+    await node.start()
+    print(
+        f"bcn ready channel={args.channel} runtime={args.runtime} endpoint={node.endpoint}",
+        flush=True,
+    )
+    try:
+        await node.wait()
+    finally:
+        await node.stop()
+    return 0
+
+
+def _daemon_command(args: argparse.Namespace, data_dir: Path) -> list[str]:
+    command = [
+        sys.executable,
+        "-m",
+        "bazaar_compute_node.cli",
+        "run",
+        "--channel",
+        args.channel,
+        "--runtime",
+        args.runtime,
+        "--storage",
+        args.storage,
+        "--audit",
+        args.audit,
+        "--endpoint",
+        str(_endpoint_path(args, data_dir)),
+    ]
+    for name in ("model", "effort", "sandbox_mode"):
+        value = getattr(args, name)
+        if value is not None:
+            command.extend((f"--{name.replace('_', '-')}", value))
+    command.append("--network-access" if args.network_access else "--no-network-access")
+    return command
+
+
+def _spawn_daemon(
+    command: Sequence[str],
+    log_path: Path,
+) -> subprocess.Popen[bytes]:
+    with log_path.open("ab") as log_file:
+        if os.name == "nt":
+            return subprocess.Popen(
+                command,
+                stdin=subprocess.DEVNULL,
+                stdout=log_file,
+                stderr=subprocess.STDOUT,
+                close_fds=True,
+                creationflags=(
+                    subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+                ),
+            )
+        return subprocess.Popen(
+            command,
+            stdin=subprocess.DEVNULL,
+            stdout=log_file,
+            stderr=subprocess.STDOUT,
+            close_fds=True,
+            start_new_session=True,
+        )
+
+
+async def _endpoint_is_reachable(
+    endpoint: str,
+    *,
+    timeout: float,
+) -> bool:
+    try:
+        response = await LocalCommandClient.request(
+            endpoint,
+            {"kind": "control", "operation": "health"},
+            timeout=timeout,
+        )
+    except Exception:  # noqa: BLE001
+        return False
+    return response.get("ok") is True
+
+
+async def _wait_for_endpoint(
+    endpoint: str,
+    process: subprocess.Popen[bytes],
+    *,
+    timeout: float,
+) -> None:
+    deadline = asyncio.get_running_loop().time() + timeout
+    while asyncio.get_running_loop().time() < deadline:
+        if await _endpoint_is_reachable(endpoint, timeout=0.5):
+            return
+        if process.poll() is not None:
+            raise RuntimeError(
+                f"daemon exited before becoming ready; see "
+                f"{resolve_data_dir() / 'bcn.log'}"
+            )
+        await asyncio.sleep(0.05)
+    raise TimeoutError(f"daemon did not become ready within {timeout:g} seconds")
+
+
+async def _wait_for_endpoint_exit(
+    endpoint: str,
+    *,
+    timeout: float,
+) -> bool:
+    deadline = asyncio.get_running_loop().time() + timeout
+    while asyncio.get_running_loop().time() < deadline:
+        if not await _endpoint_is_reachable(endpoint, timeout=0.5):
+            return True
+        await asyncio.sleep(0.05)
+    return not await _endpoint_is_reachable(endpoint, timeout=0.5)
+
+
+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)
+    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():
+        parser.error(f"bcn endpoint already exists: {endpoint_path}")
+
+    log_path = data_dir / "bcn.log"
+    daemon_command = _daemon_command(args, data_dir)
+    process = await asyncio.to_thread(_spawn_daemon, daemon_command, log_path)
+    try:
+        await _wait_for_endpoint(endpoint, process, timeout=10)
+    except BaseException:
+        if process.poll() is None:
+            process.terminate()
+            await asyncio.to_thread(process.wait, 5)
+        raise
+    print(
+        f"bcn started pid={process.pid} channel={args.channel} "
+        f"runtime={args.runtime} endpoint={endpoint}",
+        flush=True,
+    )
+    return 0
+
+
+async def _stop_daemon(
+    args: argparse.Namespace,
+    parser: argparse.ArgumentParser,
+) -> int:
+    data_dir = 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):
+        print("bcn is not running", flush=True)
+        return 0
+
+    try:
+        response = await LocalCommandClient.request(
+            endpoint,
+            {"kind": "control", "operation": "shutdown"},
+            timeout=5,
+        )
+    except Exception as error:  # noqa: BLE001
+        parser.error(f"cannot reach bcn daemon: {error}")
+    if response.get("ok") is not True:
+        parser.error(
+            f"bcn daemon rejected shutdown: {response.get('code', 'COMMAND_FAILED')}"
+        )
+    if not await _wait_for_endpoint_exit(endpoint, timeout=10):
+        parser.error(f"bcn endpoint did not stop within 10 seconds: {endpoint}")
+    print(f"bcn stopped endpoint={endpoint}", flush=True)
+    return 0
+
+
+async def _restart_daemon(
+    args: argparse.Namespace,
+    parser: argparse.ArgumentParser,
+) -> int:
+    if (args.channel is None) != (args.runtime is None):
+        parser.error("--channel and --runtime must be provided together")
+    if args.channel is None or args.runtime is None:
+        parser.error("restart requires --channel and --runtime when config is missing")
+    await _stop_daemon(args, parser)
+    return await _start_daemon(args, parser)
+
+
+async def async_main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(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()
+            return 0
+        command = "start"
+    if command == "run" or (command == "start" and args.foreground):
+        return await _run_node(args, parser)
+    if command == "start":
+        return await _start_daemon(args, parser)
+    if command == "stop":
+        return await _stop_daemon(args, parser)
+    if command == "restart":
+        return await _restart_daemon(args, parser)
+    parser.error(f"unsupported command: {command}")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    return asyncio.run(async_main(argv))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bazaar_compute_node/contrib/__init__.py

@@ -0,0 +1 @@
+"""Optional adapter implementations for the core contracts."""

bazaar_compute_node/contrib/codex_app_server/__init__.py

@@ -0,0 +1,63 @@
+"""Codex App Server process, protocol, and runtime adapter."""
+
+from .client import (
+    CodexAppServerClient,
+    CodexAppServerProtocolError,
+    CodexErrorInfo,
+    CodexThreadInfo,
+    CodexTurnInfo,
+    build_initialize_params,
+    build_thread_resume_params,
+    build_thread_start_params,
+    build_turn_interrupt_params,
+    build_turn_start_params,
+    parse_error_notification,
+    parse_thread_response,
+    parse_turn_notification,
+    parse_turn_response,
+)
+from .events import CodexTurnEventStream
+from .process import (
+    JsonlProcessSpec,
+    JsonlProcessState,
+    JsonlProcessSupervisor,
+)
+from .protocol import (
+    JsonlMessage,
+    JsonlProcessExited,
+    JsonlProcessNotRunning,
+    JsonlProtocolError,
+    JsonlRemoteError,
+    JsonlRequestTimeout,
+    JsonlTransportError,
+)
+from .runtime import CodexAppServerRuntime
+
+__all__ = [
+    "CodexAppServerClient",
+    "CodexAppServerProtocolError",
+    "CodexAppServerRuntime",
+    "CodexErrorInfo",
+    "CodexThreadInfo",
+    "CodexTurnEventStream",
+    "CodexTurnInfo",
+    "JsonlMessage",
+    "JsonlProcessExited",
+    "JsonlProcessNotRunning",
+    "JsonlProcessSpec",
+    "JsonlProcessState",
+    "JsonlProcessSupervisor",
+    "JsonlProtocolError",
+    "JsonlRemoteError",
+    "JsonlRequestTimeout",
+    "JsonlTransportError",
+    "build_initialize_params",
+    "build_thread_resume_params",
+    "build_thread_start_params",
+    "build_turn_interrupt_params",
+    "build_turn_start_params",
+    "parse_error_notification",
+    "parse_thread_response",
+    "parse_turn_notification",
+    "parse_turn_response",
+]

bazaar_compute_node/contrib/codex_app_server/approval.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import cast
+
+from ...core.models import ApprovalDecision, ApprovalRequest, ApprovalResult
+from .protocol import (
+    CodexAppServerProtocolError,
+    JsonlMessage,
+    JsonlRequestId,
+    is_request_id,
+)
+
+_COMMAND_METHOD = "item/commandExecution/requestApproval"
+_FILE_CHANGE_METHOD = "item/fileChange/requestApproval"
+_PERMISSIONS_METHOD = "item/permissions/requestApproval"
+
+_APPROVAL_METHODS = frozenset(
+    {
+        _COMMAND_METHOD,
+        _FILE_CHANGE_METHOD,
+        _PERMISSIONS_METHOD,
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CodexApprovalRequest:
+    """Provider request plus its neutral approval projection."""
+
+    request_id: JsonlRequestId
+    method: str
+    params: Mapping[str, object]
+    request: ApprovalRequest
+
+
+def is_approval_method(method: object) -> bool:
+    return isinstance(method, str) and method in _APPROVAL_METHODS
+
+
+def parse_approval_request(
+    message: JsonlMessage,
+    *,
+    session_id: str,
+    runtime_session_id: str,
+    turn_id: str,
+    provider_thread_id: str,
+    provider_turn_id: str | None,
+) -> CodexApprovalRequest:
+    method = message.get("method")
+    if not isinstance(method, str) or not is_approval_method(method):
+        raise CodexAppServerProtocolError("message is not an approval request")
+    request_id = message.get("id")
+    if not is_request_id(request_id):
+        raise CodexAppServerProtocolError(
+            "approval request id must be an integer or string"
+        )
+    request_id = cast(JsonlRequestId, request_id)
+    params = message.get("params")
+    if not isinstance(params, Mapping):
+        raise CodexAppServerProtocolError("approval request params must be an object")
+
+    thread_value = _require_text(params, "threadId")
+    if thread_value != provider_thread_id:
+        raise CodexAppServerProtocolError(
+            "approval request thread does not match runtime thread"
+        )
+    provider_turn_value = _require_text(params, "turnId")
+    if provider_turn_id is None or provider_turn_value != provider_turn_id:
+        raise CodexAppServerProtocolError(
+            "approval request turn does not match runtime turn"
+        )
+    provider_item_id = _require_text(params, "itemId")
+    started_at_ms = params.get("startedAtMs")
+    if (
+        not isinstance(started_at_ms, int)
+        or isinstance(started_at_ms, bool)
+        or started_at_ms < 0
+    ):
+        raise CodexAppServerProtocolError(
+            "approval request startedAtMs must be a non-negative integer"
+        )
+    action = {
+        _COMMAND_METHOD: "command_execution",
+        _FILE_CHANGE_METHOD: "file_change",
+        _PERMISSIONS_METHOD: "permissions",
+    }[method]
+    if method == _PERMISSIONS_METHOD and not isinstance(
+        params.get("permissions"), Mapping
+    ):
+        raise CodexAppServerProtocolError(
+            "permissions approval request has no permissions object"
+        )
+
+    metadata: dict[str, object] = {
+        "provider_method": method,
+        "provider_item_id": provider_item_id,
+    }
+    for provider_key, metadata_key in (
+        ("approvalId", "provider_approval_id"),
+        ("environmentId", "provider_environment_id"),
+    ):
+        value = params.get(provider_key)
+        if isinstance(value, str) and value:
+            metadata[metadata_key] = value
+    return CodexApprovalRequest(
+        request_id=request_id,
+        method=method,
+        params=params,
+        request=ApprovalRequest(
+            request_id=str(request_id),
+            session_id=session_id,
+            runtime_session_id=runtime_session_id,
+            action=action,
+            created_at_ms=started_at_ms,
+            turn_id=turn_id,
+            metadata=metadata,
+        ),
+    )
+
+
+def build_approval_response(
+    approval: CodexApprovalRequest,
+    result: ApprovalResult,
+) -> Mapping[str, object]:
+    if result.request_id != approval.request.request_id:
+        raise ValueError("approval result request id does not match provider request")
+    approved = result.decision is ApprovalDecision.APPROVED
+    if approval.method in {_COMMAND_METHOD, _FILE_CHANGE_METHOD}:
+        return {"decision": "accept" if approved else "decline"}
+    if approval.method == _PERMISSIONS_METHOD:
+        if not approved:
+            return {"permissions": {}}
+        permissions = approval.params.get("permissions")
+        if not isinstance(permissions, Mapping):
+            raise CodexAppServerProtocolError(
+                "permissions approval request has no permissions object"
+            )
+        return {"permissions": dict(permissions), "scope": "turn"}
+    raise CodexAppServerProtocolError("unsupported approval response method")
+
+
+def approval_error(error: BaseException) -> Mapping[str, object]:
+    """Return a provider-safe JSON-RPC error without leaking request contents."""
+
+    return {
+        "code": -32000,
+        "message": f"approval bridge failed: {type(error).__name__}",
+    }
+
+
+def _require_text(params: Mapping[str, object], field_name: str) -> str:
+    value = params.get(field_name)
+    if not isinstance(value, str) or not value:
+        raise CodexAppServerProtocolError(
+            f"approval request {field_name} must be non-empty text"
+        )
+    return value
+
+
+__all__ = [
+    "CodexApprovalRequest",
+    "approval_error",
+    "build_approval_response",
+    "is_approval_method",
+    "parse_approval_request",
+]