baserun-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{baserun_cli-0.1.4 → baserun_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baserun-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: BaseRun agent-side daemon (connects to nchan, spawns CLI agents, publishes run events)
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{baserun_cli-0.1.4 → baserun_cli-0.1.5}/baserun_cli/channel.py

@@ -82,47 +82,47 @@ class ChannelClient:
         }
 
     async def ensure_run_pub(self, run_id: str) -> None:
-        """Deprecated no-op.
+        """Pre-connect the WS publisher for a run (fire-and-forget).
 
-        WS publisher sends can succeed locally while nchan receives nothing
-        when a proxy/WebSocket keepalive breaks. Run events now use HTTP
-        publish as the authoritative, acknowledged path.
-        """
-        return
-
-    async def publish_event(self, run_id: str, payload: dict[str, Any]) -> bool:
-        """Publish a run event via HTTP and require an acknowledged response.
-
-        We intentionally avoid the WebSocket publisher for run events: send()
-        only confirms that bytes entered the local socket buffer, not that nchan
-        accepted and buffered the event. HTTP gives per-event success/failure.
+        Called at run start so the WS handshake completes before the first
+        event arrives. If this fails, publish_event will retry on demand.
         """
+        if run_id in self._run_pubs:
+            return
         try:
-            await self._http_publish(run_id, payload)
-            return True
+            ws = await self._open_run_pub(run_id)
+            self._run_pubs[run_id] = ws
         except Exception as e:
-            log.warning(
-                "http publish to run %s failed seq=%s: %s",
-                run_id,
-                payload.get("data", {}).get("seq"),
-                e,
-            )
-            return False
+            log.debug("pre-connect ws pub for run %s failed (will retry on first event): %s", run_id, e)
+
+    async def publish_event(self, run_id: str, payload: dict[str, Any]) -> bool:
+        """Publish a run event via WebSocket (ordered streaming path)."""
+        data = json.dumps(payload, ensure_ascii=False)
+        is_terminal = (payload.get("data", {}).get("finished") is True)
+        max_retries = 4 if is_terminal else 2
 
-    async def publish_event_reliably(self, run_id: str, payload: dict[str, Any]) -> bool:
-        """Publish a critical run event with HTTP retries."""
-        max_retries = 5
         for attempt in range(max_retries):
-            if await self.publish_event(run_id, payload):
+            ws = self._run_pubs.get(run_id)
+            if ws is None:
+                try:
+                    ws = await self._open_run_pub(run_id)
+                    self._run_pubs[run_id] = ws
+                except Exception as e:
+                    log.warning("ws pub connect for run %s failed (attempt %d): %s", run_id, attempt + 1, e)
+                    if attempt < max_retries - 1:
+                        await asyncio.sleep(1.0)
+                    continue
+            try:
+                await ws.send(data)
                 return True
-            if attempt < max_retries - 1:
-                await asyncio.sleep(1.0)
-        log.error(
-            "reliable publish failed for run %s seq=%s after %d attempts",
-            run_id,
-            payload.get("data", {}).get("seq"),
-            max_retries,
-        )
+            except Exception as e:
+                log.warning("ws publish to run %s failed (attempt %d): %s", run_id, attempt + 1, e)
+                self._run_pubs.pop(run_id, None)
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(1.0)
+
+        log.error("publish failed for run %s seq=%s after %d attempts",
+                   run_id, payload.get("data", {}).get("seq"), max_retries)
         return False
 
     async def _open_run_pub(self, run_id: str) -> Any:
@@ -136,12 +136,6 @@ class ChannelClient:
         log.info("opening ws publisher for run %s", run_id)
         return await connect(url, ping_interval=30, open_timeout=30)
 
-    async def _http_publish(self, run_id: str, payload: dict[str, Any]) -> None:
-        """HTTP fallback for publishing events (legacy, not used in normal flow)."""
-        url = f"{self._publish_base.rstrip('/')}/internal/run/{run_id}/publish"
-        resp = await self._http.post(url, content=json.dumps(payload, ensure_ascii=False))
-        resp.raise_for_status()
-
     async def close_run_pub(self, run_id: str) -> None:
         """Close the WS publisher for a run."""
         ws = self._run_pubs.pop(run_id, None)
@@ -228,10 +222,7 @@ class ChannelClient:
         replay_ok = True
         for ev in missing_events:
             data = ev.get("data", {})
-            if data.get("finished") is True:
-                ok = await self.publish_event_reliably(run_id, ev)
-            else:
-                ok = await self.publish_event(run_id, ev)
+            ok = await self.publish_event(run_id, ev)
             if not ok:
                 replay_ok = False
                 log.error("verify: replay still failed for run %s seq=%s", run_id, data.get("seq"))

{baserun_cli-0.1.4 → baserun_cli-0.1.5}/baserun_cli/runner.py

@@ -163,6 +163,11 @@ class TaskRunner:
         connector = get_connector(connector_type, config)
         log.info("run %s mode=%s connector=%s session_id=%s", run_id, mode, connector.spec.bin, agent_session_id or "new")
 
+        # Open the run publisher before connector starts. Otherwise a short task
+        # can finish before the run channel/subscriber is ready, leaving the
+        # server in RUNNING even though the client process completed locally.
+        await self.channel.ensure_run_pub(run_id)
+
         events_iter = self._select_events(connector, mode, prompt, agent_session_id)
 
         # local persistence: raw event log for debugging + retry
@@ -199,11 +204,8 @@ class TaskRunner:
 
                     log.debug("run %s event seq=%d kind=%s", run_id, seq, kind)
 
-                    # publish
-                    if is_terminal:
-                        await self.channel.publish_event_reliably(run_id, payload)
-                    else:
-                        await self.channel.publish_event(run_id, payload)
+                    # publish via WebSocket only
+                    await self.channel.publish_event(run_id, payload)
 
                     if is_terminal:
                         saw_terminal = True
@@ -224,7 +226,7 @@ class TaskRunner:
                     }
                     log_file.write(json.dumps(payload["data"], ensure_ascii=False) + "\n")
                     log_file.flush()
-                    await self.channel.publish_event_reliably(run_id, payload)
+                    await self.channel.publish_event(run_id, payload)
                     log.info("run %s synthesized terminal (seq=%d)", run_id, seq)
 
                 # verify-and-replay：对比 nchan 实际状态，精确补发缺失事件
@@ -268,7 +270,7 @@ class TaskRunner:
                     log_file.write(json.dumps(error_payload["data"], ensure_ascii=False) + "\n")
             except Exception:
                 pass
-            ok = await self.channel.publish_event_reliably(run_id, error_payload)
+            ok = await self.channel.publish_event(run_id, error_payload)
             return ok, "error", seq
 
         finally:

{baserun_cli-0.1.4 → baserun_cli-0.1.5}/baserun_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baserun-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: BaseRun agent-side daemon (connects to nchan, spawns CLI agents, publishes run events)
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{baserun_cli-0.1.4 → baserun_cli-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "baserun-cli"
-version = "0.1.4"
+version = "0.1.5"
 description = "BaseRun agent-side daemon (connects to nchan, spawns CLI agents, publishes run events)"
 readme = "README.md"
 requires-python = ">=3.11"