baserun-cli 0.1.0__py3-none-any.whl

baserun_cli/runner.py

@@ -0,0 +1,319 @@
+"""Task runner: receives a task envelope, drives the CLIAgentConnector, and
+publishes parsed events back to the run:{run_id} channel.
+
+Translates the vendored ConnectorEvent stream into the wire protocol:
+
+    {"type":"result","data":{"run_id":"...","seq":N,"finished":false,
+     "kind":"session|thinking|tool_call|tool_result|message|final|error|usage",
+     "content":{...}}}
+
+Terminal frame: kind=="final", finished==true.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+from typing import Any
+
+from ._vendored import (
+    CLIAgentConnector,
+    ConnectorEvent,
+    ConnectorEventType,
+    get_connector,
+)
+from .channel import ChannelClient
+
+log = logging.getLogger(__name__)
+
+# connector event type → wire kind
+_KIND_MAP = {
+    ConnectorEventType.SESSION: "session",
+    ConnectorEventType.THINKING: "thinking",
+    ConnectorEventType.TOOL_CALL: "tool_call",
+    ConnectorEventType.TOOL_RESULT: "tool_result",
+    ConnectorEventType.MESSAGE: "message",
+    ConnectorEventType.FINAL: "final",
+    ConnectorEventType.ERROR: "error",
+    ConnectorEventType.USAGE: "usage",
+}
+
+# run_id dedup persistence — survives process restart
+_RECENT_TTL = 86400  # 24h
+_MAX_RECENT = 50     # max entries (oldest trimmed)
+
+
+def _state_file(app_id: str) -> str:
+    """Per-agent state file: ~/.lark-agent-hub-runs-{app_id}.json"""
+    safe_id = app_id.replace("/", "_")
+    return os.path.join(os.path.expanduser("~"), f".lark-agent-hub-runs-{safe_id}.json")
+
+
+# State entry: {"ts": float, "status": "done"|"error", "seq": int}
+# - ts: completion timestamp (for TTL expiry + ordering)
+# - status: terminal kind ("done" = final, "error" = error frame)
+# - seq: last published event seq (ordering, similar to nchan message_id)
+RecentEntry = dict[str, Any]  # {"ts": float, "status": str, "seq": int}
+
+
+def _load_recent(app_id: str) -> dict[str, RecentEntry]:
+    path = _state_file(app_id)
+    try:
+        with open(path) as f:
+            data = json.load(f)
+        now = time.time()
+        # filter expired + migrate old format ({rid: float} → {rid: {ts, status, seq}})
+        result: dict[str, RecentEntry] = {}
+        for rid, val in data.items():
+            if isinstance(val, (int, float)):
+                # old format: {rid: timestamp}
+                ts = float(val)
+            elif isinstance(val, dict):
+                ts = float(val.get("ts", 0))
+            else:
+                continue
+            if now - ts < _RECENT_TTL:
+                if isinstance(val, dict):
+                    result[rid] = val
+                else:
+                    result[rid] = {"ts": ts, "status": "done", "seq": 0}
+        return result
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save_recent(app_id: str, recent: dict[str, RecentEntry]) -> None:
+    path = _state_file(app_id)
+    # trim to max entries (keep most recent by ts)
+    if len(recent) > _MAX_RECENT:
+        sorted_items = sorted(recent.items(), key=lambda x: x[1].get("ts", 0), reverse=True)
+        recent = dict(sorted_items[:_MAX_RECENT])
+    try:
+        with open(path, "w") as f:
+            json.dump(recent, f)
+    except OSError as e:
+        log.warning("failed to persist run history: %s", e)
+
+
+class TaskRunner:
+    def __init__(self, channel: ChannelClient, concurrency: int = 1, app_id: str = "") -> None:
+        self.channel = channel
+        self._sem = asyncio.Semaphore(max(1, concurrency))
+        self._active_runs: set[str] = set()
+        self._app_id = app_id or getattr(channel, "app_id", "")
+        self._recent_runs: dict[str, RecentEntry] = _load_recent(self._app_id)
+        if self._recent_runs:
+            log.info("loaded %d recent run_ids from %s", len(self._recent_runs), _state_file(self._app_id))
+
+    def _cleanup_recent(self) -> None:
+        now = time.time()
+        expired = [rid for rid, entry in self._recent_runs.items()
+                   if now - entry.get("ts", 0) > _RECENT_TTL]
+        for rid in expired:
+            del self._recent_runs[rid]
+        if expired:
+            _save_recent(self._app_id, self._recent_runs)
+
+    async def handle(self, envelope: dict[str, Any]) -> None:
+        """envelope = {"type":"task","data":{run_id, mode, prompt, ...}}"""
+        data = envelope.get("data") or envelope
+        run_id = data.get("run_id", "")
+
+        self._cleanup_recent()
+
+        if run_id in self._active_runs:
+            log.warning("duplicate task for run %s (already running), skipping", run_id)
+            return
+        if run_id in self._recent_runs:
+            log.warning("duplicate task for run %s (recently completed), skipping", run_id)
+            return
+
+        self._active_runs.add(run_id)
+        terminal_published = False
+        try:
+            async with self._sem:
+                terminal_published, status, last_seq = await self._run_task(data)
+        finally:
+            self._active_runs.discard(run_id)
+            # 只在 terminal 确实发布后才记入去重表
+            if terminal_published:
+                self._recent_runs[run_id] = {
+                    "ts": time.time(),
+                    "status": status,
+                    "seq": last_seq,
+                }
+                _save_recent(self._app_id, self._recent_runs)
+
+    async def _run_task(self, data: dict[str, Any]) -> tuple[bool, str, int]:
+        """Execute a run. Returns (terminal_published, status, last_seq).
+
+        Events are persisted to a local JSONL file as they are produced.
+        After the connector finishes, any events that failed to publish
+        via WS are retried via HTTP to guarantee delivery.
+        """
+        run_id = data["run_id"]
+        mode = data.get("mode", "new")
+        prompt = data["prompt"]
+        agent_session_id = data.get("agent_session_id")
+        connector_type = data.get("connector_type", "claude_code")
+        config = data.get("config") or {}
+
+        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")
+
+        events_iter = self._select_events(connector, mode, prompt, agent_session_id)
+
+        # pre-connect WS publisher (don't wait for first event — avoids 10s+ delay
+        # where early events accumulate and arrive as a burst, killing streaming UX)
+        asyncio.create_task(self.channel.ensure_run_pub(run_id))
+
+        # local persistence: raw event log for debugging + retry
+        log_dir = os.path.join(os.path.expanduser("~"), ".lark-agent-hub-logs")
+        os.makedirs(log_dir, exist_ok=True)
+        log_path = os.path.join(log_dir, f"{run_id}.jsonl")
+
+        seq = 0
+        saw_terminal = False
+        terminal_status = "done"
+
+        try:
+            with open(log_path, "w") as log_file:
+                async for ev in events_iter:
+                    seq += 1
+                    kind = _KIND_MAP.get(ev.type, "message")
+                    is_terminal = ev.type in (ConnectorEventType.FINAL, ConnectorEventType.ERROR)
+
+                    # build wire payload
+                    payload = {
+                        "type": "result",
+                        "data": {
+                            "run_id": run_id,
+                            "seq": seq,
+                            "finished": is_terminal,
+                            "kind": kind,
+                            "content": ev.payload,
+                        },
+                    }
+
+                    # persist locally
+                    log_file.write(json.dumps(payload["data"], ensure_ascii=False) + "\n")
+                    log_file.flush()
+
+                    log.debug("run %s event seq=%d kind=%s", run_id, seq, kind)
+
+                    # publish
+                    await self.channel.publish_event(run_id, payload)
+
+                    if is_terminal:
+                        saw_terminal = True
+                        terminal_status = kind
+                        log.info("run %s terminal event (kind=%s, seq=%d)", run_id, kind, seq)
+
+                if not saw_terminal:
+                    seq += 1
+                    payload = {
+                        "type": "result",
+                        "data": {
+                            "run_id": run_id,
+                            "seq": seq,
+                            "finished": True,
+                            "kind": "final",
+                            "content": {},
+                        },
+                    }
+                    log_file.write(json.dumps(payload["data"], ensure_ascii=False) + "\n")
+                    log_file.flush()
+                    ok = await self.channel.publish_event(run_id, payload)
+                    if not ok:
+                        failed_events.append(payload)
+                    log.info("run %s synthesized terminal (seq=%d)", run_id, seq)
+
+                # verify-and-replay：对比 nchan 实际状态，精确补发缺失事件
+                all_local = []
+                try:
+                    with open(log_path) as f:
+                        for line in f:
+                            line = line.strip()
+                            if line:
+                                all_local.append({"type": "result", "data": json.loads(line)})
+                except Exception:
+                    pass
+
+                if all_local:
+                    await self.channel.verify_and_replay(run_id, all_local)
+
+                log.info("run %s completed (%d events, log: %s)", run_id, seq, log_path)
+            return True, terminal_status, seq
+
+        except Exception as e:
+            log.exception("run %s failed at seq=%d", run_id, seq)
+            # publish error terminal via HTTP (reliable)
+            seq += 1
+            error_payload = {
+                "type": "result",
+                "data": {
+                    "run_id": run_id,
+                    "seq": seq,
+                    "finished": True,
+                    "kind": "error",
+                    "content": {"message": str(e)},
+                },
+            }
+            try:
+                with open(log_path, "a") as log_file:
+                    log_file.write(json.dumps(error_payload["data"], ensure_ascii=False) + "\n")
+            except Exception:
+                pass
+            await self.channel.publish_event(run_id, error_payload)
+            return True, "error", seq
+
+        finally:
+            await self.channel.close_run_pub(run_id)
+
+    def _select_events(
+        self,
+        connector: CLIAgentConnector,
+        mode: str,
+        prompt: str,
+        agent_session_id: str | None,
+    ):
+        if mode == "resume" and agent_session_id:
+            return connector.resume(agent_session_id, prompt)
+        if mode == "fork" and agent_session_id:
+            return connector.fork(agent_session_id, prompt)
+        return connector.new_session(prompt)
+
+    async def _publish_event(
+        self, run_id: str, seq: int, ev: ConnectorEvent, finished: bool
+    ) -> None:
+        kind = _KIND_MAP.get(ev.type, "message")
+        await self.channel.publish_event(
+            run_id,
+            {
+                "type": "result",
+                "data": {
+                    "run_id": run_id,
+                    "seq": seq,
+                    "finished": finished,
+                    "kind": kind,
+                    "content": ev.payload,
+                },
+            },
+        )
+
+    async def _publish_terminal(self, run_id: str, seq: int) -> None:
+        await self.channel.publish_event(
+            run_id,
+            {
+                "type": "result",
+                "data": {
+                    "run_id": run_id,
+                    "seq": seq,
+                    "finished": True,
+                    "kind": "final",
+                    "content": {},
+                },
+            },
+        )

baserun_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: baserun-cli
+Version: 0.1.0
+Summary: BaseRun agent-side daemon (connects to nchan, spawns CLI agents, publishes run events)
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=13.0
+Requires-Dist: httpx>=0.27.0
+
+# baserun-cli
+
+BaseRun agent-side daemon. It connects to the BaseRun nchan channel, runs local CLI agents, and publishes run events back to BaseRun.
+
+## Run
+
+```bash
+NCHAN_URL="wss://baserun.livesig.cn/nchan" \
+AGENT_APP_ID="<agent_id>" \
+AGENT_APP_SECRET="<agent_secret>" \
+CONNECTOR_TYPE="claude_code" \
+uvx baserun-cli
+```
+
+`CONNECTOR_TYPE` defaults to `claude_code`.
+
+## Build
+
+```bash
+cd baserun-cli
+rm -rf dist build *.egg-info
+python3 -m build
+```
+
+## Publish
+
+```bash
+cd baserun-cli
+python3 -m twine upload dist/*
+```
+
+Or with uv:
+
+```bash
+cd baserun-cli
+uv build
+uv publish
+```

baserun_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+baserun_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+baserun_cli/channel.py,sha256=zExZ6FhhnW5Q_XCEcPfoGexarMTss0V-yjRODL78egs,14706
+baserun_cli/main.py,sha256=gwF0UWym75L0m6vtKH0rigDsxfQcG5aODcw08yTMv6o,3247
+baserun_cli/runner.py,sha256=1XPA2Kg7RKmVkcnb9uEY1g8VZSyptI1hGsupMa2ImAY,11889
+baserun_cli/_vendored/__init__.py,sha256=p7Gs6VZV1iCsdT4rUYAVGHtEdFDryf0bKmSQ8n2T66w,714
+baserun_cli/_vendored/base.py,sha256=R1MW9Ele_RVM6RNRzRsJ2YytVTex4u0IEKQ5k6QPlx8,9349
+baserun_cli/_vendored/cli.py,sha256=uM-PcCibLFG4JFUa0p84V3HJ7TMR8rXDG1dCT9mJQcc,14484
+baserun_cli/_vendored/parsers/__init__.py,sha256=EfwdkaVGDooMD6Z_oToY2g80TTl-luHy8KraMmU2QJs,1235
+baserun_cli/_vendored/parsers/base.py,sha256=zLlWiGyqaHIfCkMQQzb3P1HmM0UjIB2oYtidYERzx9g,1636
+baserun_cli/_vendored/parsers/bash_agent.py,sha256=KoQ2rh7L646I2KYL2uW5kbjju_G5kmsjK0mEx9ov3Wk,3055
+baserun_cli/_vendored/parsers/claude.py,sha256=TiSrIto_2NgkRGwiMIEx7InGdod3XOlVTiA-hRjNxRo,4102
+baserun_cli/_vendored/parsers/codex.py,sha256=F4mU1w5kzvX53znxaAdKgsT2ooOdT8U9FQq025lKp6c,7065
+baserun_cli-0.1.0.dist-info/METADATA,sha256=CmWiQFcvK2jK_tsL4nLWOPoKtPwdrZCoKTfxxrFQ6vc,864
+baserun_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+baserun_cli-0.1.0.dist-info/entry_points.txt,sha256=FCe2sionsoqBvcQwHFbs7A3g23wbS0OUXIUPKxgPfXk,59
+baserun_cli-0.1.0.dist-info/top_level.txt,sha256=sG8tqnc3iyQdtUhIVjvYGxo9cmDLsuwnMU7tlCCteGw,12
+baserun_cli-0.1.0.dist-info/RECORD,,

baserun_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

baserun_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+baserun-cli = baserun_cli.main:main_sync

baserun_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+baserun_cli