byte-bot 0.1.2__tar.gz → 0.1.4__tar.gz

{byte_bot-0.1.2 → byte_bot-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: byte-bot
-Version: 0.1.2
+Version: 0.1.4
 Summary: Local dashboard for monitoring coding agents with optional Telegram status
 Project-URL: Homepage, https://github.com/erajtob/byte-bot
 Project-URL: Source, https://github.com/erajtob/byte-bot

{byte_bot-0.1.2 → byte_bot-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "byte-bot"
-version = "0.1.2"
+version = "0.1.4"
 description = "Local dashboard for monitoring coding agents with optional Telegram status"
 readme = "README.md"
 requires-python = ">=3.12"

byte_bot-0.1.4/src/byte_bot/__init__.py

@@ -0,0 +1,3 @@
+"""byte-bot."""
+
+__version__ = "0.1.4"

{byte_bot-0.1.2 → byte_bot-0.1.4}/src/byte_bot/adapters/opencode_http.py

@@ -1,9 +1,11 @@
 """Contract-checked, read-only OpenCode HTTP observation.
 
 Only an explicitly configured loopback origin is contacted. The adapter issues
-fixed read-only GET requests for server info, active-session identity and bounded
-metadata for those active sessions. It never starts OpenCode, follows redirects,
-reads transcripts/context routes or reads the live OpenCode database.
+fixed read-only GET requests for server health, active-session identity, a bounded
+newest-first session-presence list, bounded metadata, and bounded projected activity
+needed to classify current work. It never starts OpenCode, follows redirects, stores
+message content, reads arbitrary transcript/context routes, or reads the live
+OpenCode database.
 """
 
 from __future__ import annotations
@@ -18,7 +20,7 @@ import re
 import ssl
 import time
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
@@ -45,6 +47,7 @@ from byte_bot.storage import read_private_token
 
 ADAPTER_NAME = "opencode-http"
 FIELD_VERSION = "opencode-session-active-v1"
+PRESENCE_FIELD_VERSION = "opencode-session-presence-v1"
 USAGE_FIELD_VERSION = "opencode-session-metadata-v1"
 WORKSPACE_FIELD_VERSION = "opencode-session-workspace-v1"
 INTERVENTION_FIELD_VERSION = "opencode-pending-intervention-v1"
@@ -58,17 +61,20 @@ INFO_PATH = "/api/info"
 GLOBAL_HEALTH_PATH = "/global/health"
 API_HEALTH_PATH = "/api/health"
 ACTIVE_PATH = "/api/session/active"
+_SESSION_LIST_QUERY = "limit=20&order=desc"
+SESSION_LIST_PATH = f"/api/session?{_SESSION_LIST_QUERY}"
 SESSION_PATH_PREFIX = "/api/session/"
 PERMISSION_SUFFIX = "/permission"
 FORM_SUFFIX = "/form"
 MESSAGE_SUFFIX = "/message"
-_ACTIVITY_QUERY = "limit=1&order=desc&type=assistant"
+_ACTIVITY_QUERY = "limit=2&order=desc"
 _SESSION_ID_RE = re.compile(r"^ses[A-Za-z0-9_-]{1,125}$")
 _MAX_USAGE_SESSIONS = 16
 _MAX_INTERVENTION_SESSIONS = 16
 _MAX_ACTIVITY_SESSIONS = 16
+_MAX_IDLE_PROJECT_SESSIONS = 12
 _MAX_PENDING_ITEMS = 32
-_MAX_ACTIVITY_MESSAGES = 1
+_MAX_ACTIVITY_MESSAGES = 2
 _MAX_ACTIVITY_PARTS = 64
 _MAX_WORKSPACE_PATH = 4096
 _MAX_USAGE_COUNT = (1 << 63) - 1
@@ -296,6 +302,8 @@ def _route_allowed(path: str) -> bool:
     query = parsed.query
     if route in {INFO_PATH, GLOBAL_HEALTH_PATH, API_HEALTH_PATH, ACTIVE_PATH}:
         return not query
+    if route == "/api/session":
+        return query == _SESSION_LIST_QUERY
     if not route.startswith(SESSION_PATH_PREFIX):
         return False
     remainder = route.removeprefix(SESSION_PATH_PREFIX)
@@ -528,6 +536,54 @@ def _session_data(payload: object, *, native_id: str) -> dict[str, Any]:
     return data
 
 
+def _session_list_data(payload: object) -> list[dict[str, Any]]:
+    if not isinstance(payload, dict) or "data" not in payload:
+        raise _OpenCodeFailure(
+            "malformed_session_list",
+            "OpenCode session-list shape is unsupported",
+        )
+    data = payload["data"]
+    if not isinstance(data, list):
+        raise _OpenCodeFailure(
+            "malformed_session_list",
+            "OpenCode session-list shape is unsupported",
+        )
+    if len(data) > 20:
+        raise _OpenCodeFailure(
+            "too_many_sessions",
+            "OpenCode session-list limit exceeded",
+        )
+    if not all(isinstance(item, dict) for item in data):
+        raise _OpenCodeFailure(
+            "malformed_session_list",
+            "OpenCode session-list shape is unsupported",
+        )
+    return data
+
+
+def _session_updated_at(data: dict[str, Any]) -> datetime | None:
+    time_data = data.get("time")
+    if not isinstance(time_data, dict):
+        return None
+    value = time_data.get("updated")
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(value)
+        or value < 0
+    ):
+        return None
+    try:
+        return datetime.fromtimestamp(float(value) / 1000.0, tz=UTC)
+    except (OverflowError, OSError, ValueError):
+        return None
+
+
+def _session_is_archived(data: dict[str, Any]) -> bool:
+    time_data = data.get("time")
+    return isinstance(time_data, dict) and time_data.get("archived") is not None
+
+
 def _session_metadata(
     data: dict[str, Any],
     *,
@@ -653,6 +709,89 @@ def _match_project_id(
     return next(iter(matches)) if len(matches) == 1 else None
 
 
+def _idle_project_sessions(
+    rows: list[dict[str, Any]],
+    *,
+    source_id: str,
+    observed_at: datetime,
+    project_roots: tuple[tuple[str, str], ...],
+) -> tuple[Session, ...]:
+    """Project-scoped idle presence from the bounded newest-first session list."""
+
+    sessions: list[Session] = []
+    seen_projects: set[str] = set()
+    adapter_id = f"{ADAPTER_NAME}:{source_id}"
+    for data in rows:
+        if len(sessions) >= _MAX_IDLE_PROJECT_SESSIONS:
+            break
+        native_id = data.get("id")
+        if not _valid_session_id(native_id) or _session_is_archived(data):
+            continue
+        try:
+            workspace = _session_workspace(data)
+        except _OpenCodeFailure:
+            continue
+        project_id = _match_project_id(workspace, project_roots)
+        if project_id is None or project_id in seen_projects:
+            continue
+
+        model: str | None = None
+        provider: str | None = None
+        usage: Usage | None = None
+        evidence = [
+            Evidence(
+                source_kind=ADAPTER_NAME,
+                source_id=source_id,
+                field_version=PRESENCE_FIELD_VERSION,
+                observed_at=observed_at,
+            ),
+            Evidence(
+                source_kind=ADAPTER_NAME,
+                source_id=source_id,
+                field_version=WORKSPACE_FIELD_VERSION,
+                observed_at=observed_at,
+            ),
+        ]
+        try:
+            model, provider, usage = _session_metadata(
+                data,
+                observed_at=observed_at,
+            )
+        except _OpenCodeFailure:
+            pass
+        else:
+            evidence.append(
+                Evidence(
+                    source_kind=ADAPTER_NAME,
+                    source_id=source_id,
+                    field_version=USAGE_FIELD_VERSION,
+                    observed_at=observed_at,
+                )
+            )
+
+        session_id = f"{adapter_id}/{native_id}"
+        sessions.append(
+            Session(
+                id=session_id,
+                adapter_instance_id=adapter_id,
+                native_id=native_id,
+                work_id=native_id,
+                project_id=project_id,
+                model=model,
+                provider=provider,
+                lifecycle=Lifecycle.IDLE,
+                freshness=Freshness.FRESH,
+                observed_at=observed_at,
+                last_activity_at=_session_updated_at(data),
+                usage=usage,
+                evidence=tuple(evidence),
+            )
+        )
+        seen_projects.add(project_id)
+
+    return tuple(sessions)
+
+
 def _failure(
     source_id: str,
     failure: _OpenCodeFailure,
@@ -783,6 +922,78 @@ def observe_opencode(
         metadata_attempts = 0
         intervention_attempts = 0
         activity_attempts = 0
+
+        if not data and project_roots:
+            try:
+                listed_payload = fetch_json(
+                    origin,
+                    SESSION_LIST_PATH,
+                    password,
+                    timeout_seconds,
+                )
+                listed_rows = _session_list_data(listed_payload)
+            except _OpenCodeFailure as exc:
+                if exc.code not in {"http_error", "malformed_response"}:
+                    errors.append(
+                        CollectionError(
+                            code=exc.code,
+                            message=exc.message,
+                            source_id=source_id,
+                        )
+                    )
+            else:
+                idle_sessions = list(
+                    _idle_project_sessions(
+                        listed_rows,
+                        source_id=source_id,
+                        observed_at=observed_at,
+                        project_roots=project_roots,
+                    )
+                )
+                for index, session in enumerate(idle_sessions):
+                    if activity_attempts >= _MAX_ACTIVITY_SESSIONS:
+                        break
+                    activity_attempts += 1
+                    try:
+                        activity_payload = fetch_json(
+                            origin,
+                            _session_message_path(session.native_id),
+                            password,
+                            timeout_seconds,
+                        )
+                        activity = _message_activity(
+                            activity_payload,
+                            source_id=source_id,
+                            native_id=session.native_id,
+                            session_id=session.id,
+                            observed_at=observed_at,
+                        )
+                    except _OpenCodeFailure as exc:
+                        if exc.code not in {
+                            "http_error",
+                            "malformed_response",
+                            "malformed_session_activity",
+                        }:
+                            errors.append(
+                                CollectionError(
+                                    code=exc.code,
+                                    message=exc.message,
+                                    source_id=source_id,
+                                )
+                            )
+                        continue
+                    if (
+                        activity is None
+                        or activity.payload.get("state") != "RUNNING"
+                    ):
+                        continue
+                    events.append(activity)
+                    idle_sessions[index] = replace(
+                        session,
+                        lifecycle=Lifecycle.RUNNING,
+                    )
+                sessions.extend(idle_sessions)
+
         for native_id, record in sorted(data.items(), key=lambda item: str(item[0])):
             if (
                 not _valid_session_id(native_id)

byte_bot-0.1.2/src/byte_bot/__init__.py

@@ -1,3 +0,0 @@
-"""byte-bot."""
-
-__version__ = "0.1.2"