bazaar-compute-node 0.1.24__tar.gz → 0.1.26__tar.gz

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.24
+Version: 0.1.26
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.24"
+version = "0.1.26"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.24"
+version = "0.1.26"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/src/bazaar_compute_node/app/agent.py

@@ -279,8 +279,7 @@ class AgentApplication:
     async def has_session(self, session_id: str) -> bool:
         if not isinstance(session_id, str) or not session_id:
             return False
-        async with self.storage.transaction() as transaction:
-            return await transaction.get_bcn_session(session_id) is not None
+        return await self.storage.get_bcn_session(session_id) is not None
 
     async def publish_reminder_wake(self, session_id: str) -> None:
         if not self._started:
@@ -323,8 +322,7 @@ class AgentApplication:
         self._wrapper_path = None
 
     async def _referenced_attachment_paths(self) -> set[str]:
-        async with self.storage.transaction() as transaction:
-            return set(await transaction.list_ready_attachment_paths())
+        return set(await self.storage.list_ready_attachment_paths())
 
     def _adapter_context(self) -> Mapping[str, object]:
         return {
@@ -370,12 +368,11 @@ class AgentApplication:
             )
         runtime_session_id = request.get("runtime_session_id")
         session_capability = request.get("session_capability")
-        async with self.storage.transaction() as transaction:
-            if await transaction.get_bcn_session(session_id) is None:
-                raise CommandDispatchError(
-                    "SESSION_NOT_FOUND",
-                    f"unknown bcn session: {session_id}",
-                )
+        if await self.storage.get_bcn_session(session_id) is None:
+            raise CommandDispatchError(
+                "SESSION_NOT_FOUND",
+                f"unknown bcn session: {session_id}",
+            )
         runtime_session = self.orchestrator.runtime_session(session_id)
         if runtime_session is None or runtime_session_id != runtime_session.id:
             raise CommandDispatchError(

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/src/bazaar_compute_node/app/command.py

@@ -1,31 +1,78 @@
 from __future__ import annotations
 
 import asyncio
+import json
 from collections.abc import Awaitable, Callable, Mapping
 from datetime import UTC, datetime
 from time import time_ns
 from typing import Annotated, Literal, cast
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, ValidationError
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictInt,
+    StrictStr,
+    ValidationError,
+)
 
 from ..core.command import (
     ICommandService,
     InboxListResult,
+    MessageSendFreshnessHold,
     MessageSendHandoffRequired,
     SessionNotFoundError,
 )
 from ..core.lifecycle import TimeoutBudget
-from ..core.models import InboundMessage, InboxTargetSummary, OutboundMessage
+from ..core.models import (
+    InboundAttachment,
+    InboxTargetSummary,
+    Message,
+    MessageDirection,
+    OutboundAttachment,
+    OutboundDeliveryState,
+)
+
+
+def _serialize_attachment(
+    attachment: InboundAttachment | OutboundAttachment,
+) -> dict[str, object]:
+    if isinstance(attachment, InboundAttachment):
+        return {
+            "attachment_id": attachment.attachment_id,
+            "name": attachment.name,
+            "kind": attachment.kind,
+            "state": attachment.state,
+            "media_type": attachment.media_type,
+            "relative_path": attachment.relative_path,
+            "size_bytes": attachment.size_bytes,
+            "error": attachment.error,
+            "sha256": None,
+        }
+    return {
+        "attachment_id": None,
+        "name": attachment.name,
+        "kind": "file",
+        "state": "ready",
+        "media_type": attachment.media_type,
+        "relative_path": attachment.relative_path,
+        "size_bytes": attachment.size_bytes,
+        "error": None,
+        "sha256": attachment.sha256,
+    }
 
 
-def serialize_inbound(message: InboundMessage) -> dict[str, object]:
+def serialize_message(message: Message) -> dict[str, object]:
     return {
         "seq": message.seq,
         "message_id": message.message_id,
+        "direction": message.direction.value,
         "session_id": message.session_id,
         "channel_session_id": message.channel_session_id,
         "channel": message.channel,
         "received_at_ms": message.received_at_ms,
+        "created_at_ms": message.created_at_ms,
         "provider_time_ms": message.provider_time_ms,
         "sender": (
             None
@@ -34,58 +81,21 @@ def serialize_inbound(message: InboundMessage) -> dict[str, object]:
         ),
         "sender_kind": message.sender_kind.value,
         "message_type": message.message_type,
-        "canonical_target": message.canonical_target,
+        "canonical_target": message.target,
         "target_kind": message.target_kind.value,
         "mentions_agent": message.mentions_agent,
         "notifies_runtime": message.notifies_runtime,
         "attachments": [
-            {
-                "attachment_id": attachment.attachment_id,
-                "name": attachment.name,
-                "kind": attachment.kind,
-                "state": attachment.state,
-                "media_type": attachment.media_type,
-                "relative_path": attachment.relative_path,
-                "size_bytes": attachment.size_bytes,
-                "error": attachment.error,
-            }
-            for attachment in message.attachments
+            _serialize_attachment(attachment) for attachment in message.attachments
         ],
         "body": message.body,
         "reply_to_message_id": message.reply_to_message_id,
-    }
-
-
-def serialize_outbound(message: OutboundMessage) -> dict[str, object]:
-    return {
-        "outbound_message_id": message.outbound_message_id,
-        "command_id": message.command_id,
-        "session_id": message.session_id,
-        "channel_session_id": message.channel_session_id,
-        "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,
-        "snapshot_seq": message.snapshot_seq,
-        "current_inbound_seq": message.current_inbound_seq,
-        "provider_attempted_at_ms": message.provider_attempted_at_ms,
-        "completed_at_ms": message.completed_at_ms,
-        "draft_saved_at_ms": message.draft_saved_at_ms,
-        "error_kind": message.error_kind,
-        "error_message": message.error_message,
-        "next_action": message.next_action,
+        "delivery_state": (
+            message.delivery_state.value
+            if message.direction is MessageDirection.OUTBOUND
+            and message.delivery_state is not None
+            else None
+        ),
     }
 
 
@@ -172,6 +182,7 @@ class _MessageSendRequest(_CommandRequest):
     command_id: NonEmptyText
     attachment_paths: list[NonEmptyText] = Field(default_factory=list)
     reply_to_message_id: NonEmptyText | None = None
+    send_draft: StrictBool = False
     created_at_ms: NonNegativeInt = Field(
         default_factory=lambda: time_ns() // 1_000_000
     )
@@ -426,10 +437,10 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_inbound(message) for message in result.messages
+                        serialize_message(message) for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_inbound(message)
+                        serialize_message(message)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -458,10 +469,10 @@ class CommandDispatcher:
                 "ok": True,
                 "result": {
                     "messages": [
-                        serialize_inbound(message) for message in result.messages
+                        serialize_message(message) for message in result.messages
                     ],
                     "referenced_messages": [
-                        serialize_inbound(message)
+                        serialize_message(message)
                         for message in result.referenced_messages
                     ],
                     "snapshot_seq": result.snapshot_seq,
@@ -480,17 +491,59 @@ class CommandDispatcher:
                 created_at_ms=request.created_at_ms,
                 attachment_paths=tuple(request.attachment_paths),
                 reply_to_message_id=request.reply_to_message_id,
+                send_draft=request.send_draft,
             )
+            if isinstance(result, MessageSendFreshnessHold):
+                return {
+                    "ok": True,
+                    "result": {"text": format_freshness_hold(result)},
+                }
             if isinstance(result, MessageSendHandoffRequired):
                 return {
                     "ok": True,
-                    "result": {
-                        "handoff_required": {"target": result.target},
-                    },
+                    "result": {"text": format_cross_session_hold(result.target)},
                 }
+            delivery_state = result.delivery_state
+            if delivery_state is None:
+                raise RuntimeError("outbound message has no delivery state")
+            if delivery_state is OutboundDeliveryState.SENT:
+                text = (
+                    f"Message sent to {result.target}. Message ID: {result.message_id}"
+                )
+            elif delivery_state is OutboundDeliveryState.QUEUED:
+                text = (
+                    f"Message queued to {result.target}. "
+                    f"Message ID: {result.message_id}"
+                )
+            elif delivery_state is OutboundDeliveryState.PARTIAL:
+                raise CommandDispatchError(
+                    "SEND_PARTIAL",
+                    result.error_message
+                    or "Message delivery was only partially confirmed.",
+                    next_action=(
+                        "Do not retry the complete message automatically; reconcile "
+                        "confirmed delivery first."
+                    ),
+                )
+            elif delivery_state is OutboundDeliveryState.UNKNOWN:
+                raise CommandDispatchError(
+                    "SEND_UNKNOWN",
+                    result.error_message or "Message delivery outcome is unknown.",
+                    next_action="Reconcile channel delivery before retrying.",
+                )
+            elif delivery_state is OutboundDeliveryState.FAILED:
+                raise CommandDispatchError(
+                    "SEND_FAILED",
+                    result.error_message or "Message delivery failed.",
+                    next_action="Fix the provider error before retrying.",
+                )
+            else:
+                raise AssertionError(
+                    f"message send returned unsupported state: {delivery_state.value}"
+                )
             return {
                 "ok": True,
-                "result": {"outbound": serialize_outbound(result)},
+                "result": {"text": text},
             }
 
         if resource == "thread" and command == "unfollow":
@@ -507,3 +560,181 @@ def format_message_time(timestamp_ms: int) -> str:
         .astimezone()
         .strftime("%Y-%m-%d %H:%M:%S")
     )
+
+
+def _message_timestamp(message: Mapping[str, object]) -> int:
+    for field_name in ("provider_time_ms", "received_at_ms", "created_at_ms"):
+        timestamp = message.get(field_name)
+        if timestamp is not None:
+            return cast(int, timestamp)
+    raise ValueError("message has no display timestamp")
+
+
+def _message_header_fields(
+    message: Mapping[str, object],
+) -> tuple[str, str, str, str, str | None, str]:
+    target = cast(str, message["canonical_target"])
+    message_id = cast(str, message["message_id"])
+    sender_kind = cast(str, message["sender_kind"])
+    sender_value = message["sender"]
+    sender: str | None = None
+    if sender_value is not None:
+        sender_mapping = cast(Mapping[str, object], sender_value)
+        sender_id = cast(str | None, sender_mapping.get("id"))
+        sender_name = cast(str | None, sender_mapping.get("name"))
+        if sender_id is not None and sender_name is not None:
+            sender = f"@{sender_id}({sender_name})"
+        elif sender_name is not None:
+            sender = f"@{sender_name}"
+        elif sender_id is not None:
+            sender = f"@{sender_id}"
+    return (
+        target,
+        message_id,
+        format_message_time(_message_timestamp(message)),
+        sender_kind,
+        sender,
+        cast(str, message["body"]),
+    )
+
+
+def _attachment_suffix(message: Mapping[str, object]) -> str:
+    attachments = cast(list[Mapping[str, object]], message["attachments"])
+    if not attachments:
+        return ""
+    rendered: list[str] = []
+    for attachment in attachments:
+        name = cast(str, attachment["name"])
+        attachment_id = cast(str | None, attachment.get("attachment_id"))
+        state = cast(str, attachment["state"])
+        identity = f"id:{attachment_id}, " if attachment_id is not None else ""
+        if state == "ready":
+            path = cast(str, attachment["relative_path"])
+            rendered.append(f"{name} ({identity}path:{path})")
+        else:
+            error = cast(str, attachment["error"])
+            rendered.append(f"{name} ({identity}state:failed, error:{error})")
+    label = "attachment" if len(rendered) == 1 else "attachments"
+    return f" [{len(rendered)} {label}: {', '.join(rendered)}]"
+
+
+def format_check_message(message: Mapping[str, object]) -> str:
+    target, message_id, timestamp, sender_kind, sender, body = _message_header_fields(
+        message
+    )
+    line = (
+        f"[target={target} msg={message_id} time={timestamp} "
+        f"type={sender_kind} mentioned={str(message['mentions_agent']).lower()}"
+    )
+    reply_to_message_id = message["reply_to_message_id"]
+    if reply_to_message_id is not None:
+        line += f" reply_to={cast(str, reply_to_message_id)}"
+    line += "] "
+    if sender is not None:
+        line += f"{sender} "
+    return line + body + _attachment_suffix(message)
+
+
+def format_read_message(
+    message: Mapping[str, object],
+    *,
+    index: int,
+    count: int,
+) -> str:
+    target, message_id, timestamp, sender_kind, sender, body = _message_header_fields(
+        message
+    )
+    fields = [
+        f"seq={cast(int, message['seq'])}",
+        f"msg={message_id}",
+        f"time={timestamp}",
+        f"type={sender_kind}",
+        f"replyTarget={target}",
+        f"mentioned={str(message['mentions_agent']).lower()}",
+    ]
+    reply_to_message_id = message["reply_to_message_id"]
+    if reply_to_message_id is not None:
+        fields.append(f"replyTo={cast(str, reply_to_message_id)}")
+    line = f"[{index}/{count} {' '.join(fields)}] "
+    if sender is not None:
+        line += f"{sender} "
+    return line + body + _attachment_suffix(message)
+
+
+def format_freshness_hold(result: MessageSendFreshnessHold) -> str:
+    messages = [serialize_message(message) for message in result.messages]
+    referenced_messages = [
+        serialize_message(message) for message in result.referenced_messages
+    ]
+    shown = len(messages)
+    total = result.newer_message_total
+    message_label = "message" if total == 1 else "messages"
+    if messages:
+        bounds = f"{messages[0]['seq']}-{messages[-1]['seq']}"
+    else:
+        bounds = "none-none"
+    older_bound = (
+        "Older unreviewed messages are omitted."
+        if total > shown
+        else "No older unreviewed messages."
+    )
+    newer_bound = "No newer unreviewed messages."
+    lines = [
+        f"Unreviewed synced context for this target: {total} {message_label}.",
+        (
+            "Your message has been saved as a draft. Review this target's "
+            "synced context before sending."
+        ),
+        "",
+        (
+            f"Read window: {shown} returned, seq {bounds}, oldest to newest. "
+            f"{older_bound} {newer_bound}"
+        ),
+        "",
+    ]
+    if referenced_messages:
+        lines.append(f"Referenced messages: {len(referenced_messages)}")
+        lines.extend(
+            format_read_message(message, index=index, count=len(referenced_messages))
+            for index, message in enumerate(referenced_messages, start=1)
+        )
+        lines.append("Window messages:")
+    lines.extend(
+        format_read_message(message, index=index, count=shown)
+        for index, message in enumerate(messages, start=1)
+    )
+    lines.extend(
+        (
+            "",
+            f"End of window: {shown}/{total} shown.",
+            "",
+            "To update the draft, send revised content normally:",
+            f"  bcc message send --target {json.dumps(result.target)} <<'BCCMSG'",
+            "  revised message",
+            "  BCCMSG",
+            "To send the current draft unchanged:",
+            f"  bcc message send --send-draft --target {json.dumps(result.target)}",
+            "You can also choose not to send anything.",
+        )
+    )
+    return "\n".join(lines)
+
+
+def format_cross_session_hold(target: str) -> str:
+    quoted_target = json.dumps(target)
+    return "\n".join(
+        (
+            "Your message was not sent because the target belongs to another conversation.",
+            "",
+            (
+                "To continue this work in the target conversation, send a "
+                "self-contained handoff:"
+            ),
+            f"  bcc handoff send --target {quoted_target} <<'BCCMSG'",
+            "  enough context to understand the background, goal, and next action",
+            "  BCCMSG",
+            "This creates a handoff notice that wakes you in that conversation.",
+            "",
+            "You can also choose not to send anything.",
+        )
+    )

{bazaar_compute_node-0.1.24 → bazaar_compute_node-0.1.26}/src/bazaar_compute_node/app/system_service.py

@@ -271,6 +271,29 @@ exit $exitCode
 """
 
 
+def _vbs_literal(value: Path | str) -> str:
+    return '"' + str(value).replace('"', '""') + '"'
+
+
+def _render_windows_launcher(wrapper_path: Path) -> str:
+    command = _vbs_literal(
+        "powershell.exe -NoProfile -NonInteractive -WindowStyle Hidden "
+        f'-ExecutionPolicy Bypass -File "{wrapper_path}"'
+    )
+    return f"""' {MANAGED_MARKER}
+Option Explicit
+
+Dim shell
+Dim command
+Dim exitCode
+
+Set shell = CreateObject("WScript.Shell")
+command = {command}
+exitCode = shell.Run(command, 0, True)
+WScript.Quit exitCode
+"""
+
+
 def _add_task_element(
     parent: ElementTree.Element,
     name: str,
@@ -284,7 +307,7 @@ def _add_task_element(
 
 def _render_windows_task(
     context: SystemServiceContext,
-    wrapper_path: Path,
+    launcher_path: Path,
 ) -> bytes:
     ElementTree.register_namespace("", TASK_NAMESPACE)
     task = ElementTree.Element(
@@ -323,11 +346,11 @@ def _render_windows_task(
         {"Context": "Author"},
     )
     action = _add_task_element(actions, "Exec")
-    _add_task_element(action, "Command", "powershell.exe")
+    _add_task_element(action, "Command", "wscript.exe")
     _add_task_element(
         action,
         "Arguments",
-        f'-NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File "{wrapper_path}"',
+        f'//B //Nologo "{launcher_path}"',
     )
     _add_task_element(action, "WorkingDirectory", str(context.data_dir))
     return ElementTree.tostring(task, encoding="utf-16", xml_declaration=True)
@@ -423,10 +446,11 @@ def _launchd_paths() -> tuple[Path, Path]:
     )
 
 
-def _windows_paths(context: SystemServiceContext) -> tuple[Path, Path]:
+def _windows_paths(context: SystemServiceContext) -> tuple[Path, Path, Path]:
     return (
         context.data_dir / "bcn-system-service.xml",
         context.data_dir / "bcn-system-service.ps1",
+        context.data_dir / "bcn-system-service.vbs",
     )
 
 
@@ -462,16 +486,21 @@ def _install_macos(context: SystemServiceContext) -> None:
 
 
 def _install_windows(context: SystemServiceContext) -> None:
-    xml_path, wrapper_path = _windows_paths(context)
+    xml_path, wrapper_path, launcher_path = _windows_paths(context)
     context.data_dir.mkdir(parents=True, exist_ok=True)
     _write_managed_file(
         wrapper_path,
         _render_windows_wrapper(context),
         mode=0o600,
     )
+    _write_managed_file(
+        launcher_path,
+        _render_windows_launcher(wrapper_path),
+        mode=0o600,
+    )
     _write_managed_file(
         xml_path,
-        _render_windows_task(context, wrapper_path),
+        _render_windows_task(context, launcher_path),
         mode=0o600,
     )
     _run_native_command(
@@ -686,15 +715,20 @@ def _uninstall_macos() -> None:
 
 
 def _uninstall_windows(context: SystemServiceContext) -> None:
-    xml_path, wrapper_path = _windows_paths(context)
+    xml_path, wrapper_path, launcher_path = _windows_paths(context)
     _stop_windows(context)
     _run_native_command(
         ["schtasks", "/Delete", "/TN", WINDOWS_TASK_NAME, "/F"],
         check=False,
     )
     _remove_managed_file(xml_path)
+    _remove_managed_file(launcher_path)
     _remove_managed_file(wrapper_path)
-    if not xml_path.exists() and not wrapper_path.exists():
+    if (
+        not xml_path.exists()
+        and not launcher_path.exists()
+        and not wrapper_path.exists()
+    ):
         print("system service uninstalled platform=windows", flush=True)