notrack-cli-agent 0.6.0__py3-none-any.whl

notrack_cli/__init__.py

@@ -0,0 +1,2 @@
+"""NoTrack CLI Package."""
+__version__ = "0.6.0"

notrack_cli/client.py

@@ -0,0 +1,196 @@
+"""NoTrack web-chat transport.
+
+Uses the observed dispatch route and SSE-style responses. Payload shape is
+configurable because NoTrack's private web protocol may change.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from typing import Iterator, Any
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+DEFAULT_BASE_URL = "https://notrack.ai"
+DEFAULT_ENDPOINT = "/api/dispatch"
+
+
+class NoTrackAPIError(RuntimeError):
+    """Remote endpoint returned an error or an unsupported response."""
+
+
+class NoTrackClient:
+    def __init__(self, *, base_url: str | None = None, endpoint: str | None = None,
+                 model: str | None = None, mode: str | None = None,
+                 timeout: tuple[int, int] = (15, 180)):
+        self.base_url = (base_url or os.getenv("NOTRACK_BASE_URL", DEFAULT_BASE_URL)).rstrip("/")
+        self.endpoint_path = endpoint or os.getenv("NOTRACK_DISPATCH_PATH", DEFAULT_ENDPOINT)
+        self.endpoint = self.base_url + "/" + self.endpoint_path.lstrip("/")
+        self.model = model or os.getenv("NOTRACK_MODEL", "C")
+        self.mode = mode or os.getenv("NOTRACK_MODE", "usual")
+        self.persona = mode or os.getenv("NOTRACK_PERSONA", "normal")
+        self.timeout = timeout
+        self.session = self._build_session()
+        self.chat_id: str | None = None
+        self.user_id: str | None = None
+        self.last_meta: dict[str, Any] = {}
+        # New anonymous web-style identity for this CLI process.
+        self._session_id = uuid.uuid4().hex
+        self._uid = str(uuid.uuid4())
+        self.session.cookies.set("si_usr_id", self._session_id, domain="notrack.ai")
+        self.session.cookies.set("si_ses_id", self._session_id, domain="notrack.ai")
+        self.session.cookies.set("uid", self._uid, domain="notrack.ai")
+
+    def _build_session(self) -> requests.Session:
+        session = requests.Session()
+        retry = Retry(total=2, connect=2, read=0, status=2, backoff_factor=0.6,
+                      status_forcelist=(429, 500, 502, 503, 504),
+                      allowed_methods=frozenset({"GET"}), raise_on_status=False)
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        session.headers.update({
+            "Accept": "text/event-stream, application/json",
+            "Content-Type": "application/json",
+            "Origin": self.base_url,
+            "Referer": self.base_url + "/chat",
+            "User-Agent": "NoTrack-CLI/0.6 (Python requests)",
+        })
+        return session
+
+    def new_chat(self) -> None:
+        self.chat_id = None
+
+    def list_chats(self) -> list[dict[str, Any]]:
+        """Read chats using the same HTTP session/cookies as dispatch."""
+        url = self.base_url + "/api/chats"
+        response = self.session.get(url, timeout=self.timeout[0])
+        if response.status_code >= 400:
+            raise NoTrackAPIError(f"GET /api/chats: HTTP {response.status_code}: {response.text[:500]}")
+        try:
+            data = response.json()
+        except ValueError as exc:
+            raise NoTrackAPIError("GET /api/chats did not return JSON") from exc
+        if isinstance(data, dict):
+            self.user_id = data.get("user_id") or self.user_id
+            chats = data.get("chats", [])
+            return chats if isinstance(chats, list) else []
+        if isinstance(data, list):
+            return data
+        return []
+
+    def send_message_stream(self, user_input: str, mode: str | None = None,
+                            persona: str = "normal") -> Iterator[dict[str, Any]]:
+        """Send one prompt and yield normalized SSE/JSON events.
+
+        The field set matches the project's prior dispatch attempt, but is not
+        represented as a verified/current NoTrack contract.
+        """
+        payload: dict[str, Any] = {
+            "user_input": user_input,
+            "mode": mode or self.mode,
+            "model": self.model,
+            "persona": self.persona,
+            "max_turns": 6,
+            "attachments": [],
+            "regenerate": False,
+        }
+        if self.chat_id:
+            payload["chat_id"] = self.chat_id
+
+        try:
+            response = self.session.post(self.endpoint, json=payload, stream=True,
+                                         timeout=self.timeout)
+        except requests.RequestException as exc:
+            raise NoTrackAPIError(f"Could not connect to {self.endpoint}: {exc}") from exc
+
+        with response:
+            if response.status_code >= 400:
+                excerpt = response.text[:1200]
+                raise NoTrackAPIError(f"POST {self.endpoint_path}: HTTP {response.status_code}: {excerpt}")
+            content_type = response.headers.get("Content-Type", "").lower()
+            if "json" in content_type and "event-stream" not in content_type:
+                try:
+                    obj = response.json()
+                except ValueError as exc:
+                    raise NoTrackAPIError("Endpoint returned invalid JSON") from exc
+                if isinstance(obj, dict) and obj.get("type") == "error":
+                    raise NoTrackAPIError(str(obj.get("content") or obj))
+                if isinstance(obj, dict):
+                    yield from self._handle_event(obj)
+                else:
+                    yield {"type": "message", "content": json.dumps(obj, ensure_ascii=False)}
+                return
+
+            for event in self._iter_sse(response):
+                if event.get("type") == "error":
+                    raise NoTrackAPIError(str(event.get("content") or event))
+                yield from self._handle_event(event)
+
+    def _handle_event(self, event: dict[str, Any]) -> Iterator[dict[str, Any]]:
+        kind = str(event.get("type", ""))
+        if kind in {"chat_meta", "metadata", "meta"}:
+            self.last_meta.update(event)
+            if event.get("chat_id"):
+                self.chat_id = str(event["chat_id"])
+            if event.get("user_id"):
+                self.user_id = str(event["user_id"])
+            yield event
+        elif kind in {"delta", "token", "text_delta", "content_block_delta"}:
+            chunk = event.get("chunk", event.get("content", event.get("text", "")))
+            if isinstance(chunk, dict):
+                chunk = chunk.get("text", "")
+            if chunk:
+                yield {"type": "delta", "chunk": str(chunk), "raw": event}
+        elif kind in {"message", "final", "done", "response"}:
+            content = event.get("content", event.get("message", event.get("text", "")))
+            if isinstance(content, dict):
+                content = content.get("content", content.get("text", ""))
+            if content:
+                yield {"type": "message", "content": str(content), "raw": event}
+            else:
+                yield event
+        elif kind:
+            yield event
+        elif any(k in event for k in ("content", "text", "chunk")):
+            content = event.get("chunk", event.get("content", event.get("text", "")))
+            if content:
+                yield {"type": "delta", "chunk": str(content), "raw": event}
+
+    @staticmethod
+    def _iter_sse(response: requests.Response) -> Iterator[dict[str, Any]]:
+        """Read data lines, allowing multiple data: lines per SSE event."""
+        data_lines: list[str] = []
+        for raw in response.iter_lines(decode_unicode=True):
+            if raw is None:
+                continue
+            line = raw if isinstance(raw, str) else raw.decode("utf-8", errors="replace")
+            if not line:
+                if data_lines:
+                    parsed = NoTrackClient._decode_sse_data("\n".join(data_lines))
+                    if parsed is not None:
+                        yield parsed
+                    data_lines.clear()
+                continue
+            if line.startswith(":"):
+                continue
+            if line.startswith("data:"):
+                data_lines.append(line[5:].lstrip())
+        if data_lines:
+            parsed = NoTrackClient._decode_sse_data("\n".join(data_lines))
+            if parsed is not None:
+                yield parsed
+
+    @staticmethod
+    def _decode_sse_data(raw: str) -> dict[str, Any] | None:
+        if not raw or raw == "[DONE]":
+            return None
+        try:
+            obj = json.loads(raw)
+        except ValueError:
+            return {"type": "delta", "chunk": raw}
+        return obj if isinstance(obj, dict) else {"type": "message", "content": str(obj)}