machina-cli 0.4.4__tar.gz → 0.4.7__tar.gz

{machina_cli-0.4.4 → machina_cli-0.4.7}/.github/workflows/release.yml

@@ -78,15 +78,25 @@ jobs:
           # Write to file for gh release
           echo "$notes" > release_notes.md
 
-      - name: Create GitHub Release
+      - name: Create or update GitHub Release
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
           tag="${GITHUB_REF#refs/tags/}"
-          gh release create "$tag" \
-            --title "$tag" \
-            --notes-file release_notes.md \
-            artifacts/**/*
+          # Idempotent: a release may already exist if it was created from the GitHub
+          # UI / `gh release create` (which also creates the tag that triggers this
+          # workflow). In that case `gh release create` errors ("already exists") and
+          # the built binaries never get attached — leaving an empty release. So if the
+          # release exists, refresh its notes and upload the assets with --clobber.
+          if gh release view "$tag" >/dev/null 2>&1; then
+            gh release edit "$tag" --title "$tag" --notes-file release_notes.md
+            gh release upload "$tag" artifacts/**/* --clobber
+          else
+            gh release create "$tag" \
+              --title "$tag" \
+              --notes-file release_notes.md \
+              artifacts/**/*
+          fi
 
   publish-pypi:
     needs: [github-release]

{machina_cli-0.4.4 → machina_cli-0.4.7}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to machina-cli are documented here.
 
+## [0.4.7] - 2026-06-30
+
+### Added
+- **The harness loop can now read documents and real conversations.** Its tool catalog gained `read_documents` (read any document on the project pod by name — copilot threads, harness sessions, fixtures, config docs, via the same `document_search` the MCP uses) and `fetch_conversations` (recent real SportingBOT end-user chat transcripts from PostHog — user context + bot answer + category, read from `posthog.ai_events`). Before, the loop only had `find_fixtures`/`calculate`/`get_datetime`/`echo`, so "analyse the recent chats and suggest bot improvements" got "give me the logs"; it now pulls live transcripts and returns grounded, evaluator-checked findings. (#41)
+
+### Fixed
+- **`machina login --api-key` no longer discards a valid key.** The key was verified against `login/session`, which returns 5xx for API-key auth; the client read that as "key invalid", deleted the just-stored key, and silently fell back to the session token (printing "Authenticated as Unknown"). The client now never clears the key on a 5xx — it falls back for the current request only, and only when a session-token retry actually succeeds — and `login --api-key` verifies without that fallback and reports an honest result. The key is always kept. (#42)
+- **Release pipeline no longer ships empty releases.** The `github-release` CI step used `gh release create`, which errors when the release already exists (e.g. cut from the GitHub UI, which also creates the triggering tag) and then dies before attaching the binaries. It is now idempotent — create, or upload assets onto the existing release. (#43)
+
 ## [0.4.4] - 2026-06-30
 
 ### Fixed

{machina_cli-0.4.4 → machina_cli-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machina-cli
-Version: 0.4.4
+Version: 0.4.7
 Summary: CLI for the Machina AI Agent platform
 Project-URL: Homepage, https://machina.gg
 Project-URL: Repository, https://github.com/machina-sports/machina-cli

{machina_cli-0.4.4 → machina_cli-0.4.7}/docs/harness-loop-kit/provision.py

@@ -23,7 +23,7 @@ What it creates (maps to the Loop-Engineering five moves — see VALIDATION.md):
     prompt    loop-evaluate    INDEPENDENT verifier: judge the answer        (verification)
     prompt    loop-repair      bounded self-repair of a rejected answer      (Cap 8.2)
     prompt    loop-evaluate-2  re-verify the repaired answer                 (Cap 8.2)
-    connector loop-tools       dispatcher: calculate / get_datetime / echo / find_fixtures
+    connector loop-tools       dispatcher: calculate / get_datetime / echo / find_fixtures / read_documents / fetch_conversations
     workflow  loop-turn        load -> ingest -> reason -> tool -> respond -> EVALUATE -> [repair -> re-eval] -> finalize
     workflow  loop-resume      beat path: resume an orphaned `active` session  (scheduling)
     agent     loop-runner      executor path (inactive; CLI/MCP invokes it)
@@ -98,7 +98,7 @@ def _create(kind, body):
 # --- loop-tools connector source (pyscript, exec'd from the DB at call time) ---
 # Returns {status: True, data: {...}} — the connector contract; a bare dict is
 # treated as a FAILED connector. Inputs arrive under request_data['params'].
-LOOP_TOOLS_SRC = r'''"""Machina Loop Tools — meta-dispatcher (calculate/get_datetime/echo/find_fixtures)."""
+LOOP_TOOLS_SRC = r'''"""Machina Loop Tools — meta-dispatcher (calculate/get_datetime/echo/find_fixtures/read_documents/fetch_conversations)."""
 import ast, json, operator
 from datetime import datetime, timezone
 _OPS={ast.Add:operator.add,ast.Sub:operator.sub,ast.Mult:operator.mul,ast.Div:operator.truediv,ast.Pow:operator.pow,ast.Mod:operator.mod,ast.USub:operator.neg,ast.UAdd:operator.pos,ast.FloorDiv:operator.floordiv}
@@ -136,6 +136,78 @@ def _find_fixtures(a):
                     "home_analysis":(tf.get("home") or {}).get("analysis","")[:300] if v.get("has_pre_match_research") else "",
                     "away_analysis":(tf.get("away") or {}).get("analysis","")[:300] if v.get("has_pre_match_research") else ""})
     return out if out else "no upcoming fixtures found"+((" for team "+team) if team else "")
+def _read_documents(a):
+    # General doc reader: reads recent documents on THIS pod by exact name, using the
+    # SAME core.document.controller the MCP uses. Gives the loop eyes on its own pod
+    # (copilot-thread, harness_session, sportradar-fixture, config docs, ...).
+    try:
+        from core.document.controller import document_search
+    except Exception as ex:
+        return "read_documents unavailable: "+str(ex)
+    name=str(a.get("name","")).strip()
+    if not name:
+        return "read_documents needs name (e.g. copilot-thread, harness_session, sportradar-fixture)"
+    try: limit=int(a.get("limit",5))
+    except Exception: limit=5
+    contains=str(a.get("contains","")).strip().lower()
+    r=document_search(filters={"name":name},page=1,page_size=max(1,min(limit,10)),sorters=["created",-1])
+    dd=r.get("data") if isinstance(r,dict) else None
+    docs=dd.get("data") if isinstance(dd,dict) else (dd if isinstance(dd,list) else [])
+    out=[]
+    for d in (docs or []):
+        s=json.dumps(d.get("value",{}) or {},ensure_ascii=False,default=str)
+        if contains and contains not in s.lower(): continue
+        out.append({"name":d.get("name"),"created":str(d.get("created","")),"value":s[:900]})
+    return out if out else ("no '"+name+"' documents found")
+def _fetch_conversations(a):
+    # Real SportingBOT end-user chats from PostHog. Verbatim text lives on the
+    # posthog.ai_events table (input/output_choices, anchored on trace_id, 30d retention);
+    # events carries only metadata. Key read from the posthog-surface-config doc (same as
+    # the surface-verify defense). Returns recent (user-context, bot-answer, category).
+    import urllib.request
+    try:
+        from core.document.controller import document_search
+    except Exception as ex:
+        return "fetch_conversations unavailable: "+str(ex)
+    key=""; pid_doc=""
+    try:
+        r=document_search(filters={"name":"posthog-surface-config"},page=1,page_size=1)
+        dd=r.get("data") if isinstance(r,dict) else None
+        docs=dd.get("data") if isinstance(dd,dict) else (dd if isinstance(dd,list) else [])
+        if docs:
+            v=docs[0].get("value",{}) or {}
+            key=v.get("query_key","") or v.get("posthog_query_key","") or v.get("key","") or v.get("posthog_key","")
+            pid_doc=str(v.get("project","") or "")
+    except Exception as ex:
+        return "fetch_conversations: cannot read posthog key: "+str(ex)
+    if not key or str(key).startswith("$"):
+        return "fetch_conversations: no posthog key in posthog-surface-config doc"
+    pid=str(a.get("project_id") or pid_doc or "257767").strip() or "257767"
+    try: limit=int(a.get("limit",4))
+    except Exception: limit=4
+    limit=max(1,min(limit,6))
+    cat=str(a.get("category","")).replace("'","").strip()
+    catf=("AND properties.sbot_category = '"+cat+"' ") if cat else ""
+    q=("WITH t AS (SELECT properties.$ai_trace_id AS tid, properties.sbot_category AS cat, timestamp AS ts "
+       "FROM events WHERE event='$ai_generation' AND timestamp >= now() - INTERVAL 72 HOUR "
+       "AND properties.$ai_trace_id != '' "+catf+
+       "ORDER BY timestamp DESC LIMIT "+str(limit)+") "
+       "SELECT t.cat AS category, right(toString(a.input),260) AS user_ctx, "
+       "substring(toString(a.output_choices),1,300) AS bot "
+       "FROM posthog.ai_events AS a INNER JOIN t ON a.trace_id=t.tid "
+       "ORDER BY t.ts DESC LIMIT "+str(limit))
+    body=json.dumps({"query":{"kind":"HogQLQuery","query":q}}).encode()
+    req=urllib.request.Request("https://us.posthog.com/api/projects/"+pid+"/query/",data=body,
+        headers={"Authorization":"Bearer "+key,"Content-Type":"application/json"},method="POST")
+    try:
+        with urllib.request.urlopen(req,timeout=45) as resp:
+            data=json.loads(resp.read() or "{}")
+    except Exception as ex:
+        return "fetch_conversations posthog error: "+str(ex)[:160]
+    out=[]
+    for row in (data.get("results") or []):
+        out.append({"category":row[0],"user_ctx":(row[1] or "")[:240],"bot":(row[2] or "")[:240]})
+    return out if out else "no recent conversations found"
 def dispatch(request_data: dict) -> dict:
     p=request_data.get("params",{}) or request_data
     tool=(p.get("tool_name") or "").strip()
@@ -145,17 +217,23 @@ def dispatch(request_data: dict) -> dict:
     except Exception:
         args={}
     if tool=="find_fixtures": r=_find_fixtures(args)
+    elif tool=="read_documents": r=_read_documents(args)
+    elif tool=="fetch_conversations": r=_fetch_conversations(args)
     elif tool=="get_datetime": r=datetime.now(timezone.utc).strftime("%A, %d %B %Y, %H:%M UTC")
     elif tool=="calculate": r=_calc(args)
     elif tool=="echo": r=str(args.get("text",""))
     else: r="unknown tool: "+tool
     return {"status": True, "data": {"tool_result": json.dumps(r, ensure_ascii=False, default=str)[:2800],
-                                     "tool_ok": tool in ("find_fixtures","get_datetime","calculate","echo")}}
+                                     "tool_ok": tool in ("find_fixtures","read_documents","fetch_conversations","get_datetime","calculate","echo")}}
 '''
 
 CATALOG = [
     {"name": "find_fixtures", "params_hint": "team(str), limit(int=5)",
      "description": "Upcoming football fixtures (real project data) + AI pre-match analysis. Use for schedule / who-plays / pre-match questions."},
+    {"name": "read_documents", "params_hint": "name*(str), limit(int=5), contains(str?)",
+     "description": "Read recent documents stored on THIS project pod by exact name (e.g. copilot-thread, harness_session, sportradar-fixture, config docs). Use to inspect saved conversations/state on the pod before answering."},
+    {"name": "fetch_conversations", "params_hint": "limit(int=4), category(str?)",
+     "description": "Recent REAL SportingBOT end-user chat transcripts from PostHog (user context + bot answer + category). Use to analyze conversation quality and suggest concrete bot improvements."},
     {"name": "calculate", "params_hint": "expression*(str)", "description": "Evaluate arithmetic; never compute it yourself."},
     {"name": "get_datetime", "params_hint": "(no args)", "description": "Current UTC date/time."},
     {"name": "echo", "params_hint": "text*(str)", "description": "Echo text back verbatim."},
@@ -247,6 +325,8 @@ REASON_INSTR = (
     "- For ANY math -> needs_tool_call=true, call calculate {expression}. Never compute yourself.\n"
     "- For current date/time -> call get_datetime.\n"
     "- For upcoming matches / schedule / pre-match analysis -> call find_fixtures {team?, limit?}.\n"
+    "- To inspect saved documents/conversations/state on this pod (copilot-thread, harness_session, fixtures, config) -> call read_documents {name, limit?, contains?}.\n"
+    "- To analyze recent SportingBOT user chats or suggest bot improvements -> call fetch_conversations {limit?, category?}.\n"
     "- To repeat text -> call echo {text}.\n"
     "- Otherwise answer directly: needs_tool_call=false.\n"
     "name = exact tool from _3-available-tools; arguments_json = JSON-stringified args ('{}' if none). short_message = 1 line.")

{machina_cli-0.4.4 → machina_cli-0.4.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "machina-cli"
-version = "0.4.4"
+version = "0.4.7"
 description = "CLI for the Machina AI Agent platform"
 readme = "README.md"
 requires-python = ">=3.10"

machina_cli-0.4.7/src/machina_cli/client.py

@@ -0,0 +1,134 @@
+"""HTTP client for Machina Core API."""
+
+from typing import Optional
+
+import httpx
+from rich.console import Console
+
+from machina_cli.config import get_api_url, get_credential, resolve_auth_token
+
+console = Console(stderr=True)
+
+TIMEOUT = 30.0
+
+
+class MachinaClient:
+    """HTTP client that handles authentication and error formatting."""
+
+    def __init__(self, api_url: Optional[str] = None):
+        self.api_url = (api_url or get_api_url()).rstrip("/")
+
+    def _headers(self) -> dict:
+        header_name, token = resolve_auth_token()
+        headers = {"Content-Type": "application/json"}
+        if header_name and token:
+            headers[header_name] = token
+        else:
+            console.print("[red]Not authenticated. Run `machina login` first.[/red]")
+            raise SystemExit(1)
+        return headers
+
+    def _handle_response(self, response: httpx.Response, quiet: bool = False) -> dict:
+        data = {}
+        try:
+            data = response.json()
+        except Exception:
+            pass
+
+        # Extract error message from response body if available
+        error_msg = ""
+        if isinstance(data, dict):
+            error = data.get("error", {})
+            if isinstance(error, dict):
+                error_msg = error.get("message", "")
+
+        def emit(*args):
+            if not quiet:
+                console.print(*args)
+
+        if response.status_code == 401:
+            emit(f"[red]{error_msg or 'Session expired.'}[/red]")
+            emit("[yellow]Run `machina login` to re-authenticate.[/yellow]")
+            raise SystemExit(1)
+        if response.status_code == 403:
+            emit(f"[red]{error_msg or 'Permission denied.'}[/red]")
+            raise SystemExit(1)
+        if response.status_code == 404:
+            emit(f"[red]{error_msg or 'Resource not found.'}[/red]")
+            raise SystemExit(1)
+        if response.status_code >= 500:
+            emit(f"[red]{error_msg or 'Server error. Try again later.'}[/red]")
+            raise SystemExit(1)
+
+        if isinstance(data, dict) and data.get("status") == "error":
+            emit(f"[red]Error: {error_msg or 'Unknown error'}[/red]")
+            raise SystemExit(1)
+
+        return data
+
+    def _request(self, method: str, path: str, **kwargs) -> dict:
+        """Execute a request, optionally falling back from API key to session token on 5xx."""
+        url = f"{self.api_url}/{path.lstrip('/')}"
+        skip_auth = kwargs.pop("skip_auth", False)
+        allow_fallback = kwargs.pop("allow_fallback", True)
+        quiet = kwargs.pop("quiet", False)
+        headers = {"Content-Type": "application/json"} if skip_auth else self._headers()
+        try:
+            with httpx.Client(timeout=TIMEOUT) as client:
+                response = getattr(client, method)(url, headers=headers, **kwargs)
+
+                # A 5xx while sending an API key is ambiguous: the key may be invalid,
+                # the endpoint may not accept API-key auth (it 500s instead of 401), or
+                # the server may simply be faulting. Fall back to the session token for
+                # THIS request only — never delete the stored key on a 5xx (that would
+                # silently discard a possibly-valid key, e.g. during `login --api-key`).
+                if allow_fallback and response.status_code >= 500 and headers.get("X-Api-Token"):
+                    session = get_credential("session_token")
+                    if session:
+                        retry_headers = {k: v for k, v in headers.items() if k != "X-Api-Token"}
+                        retry_headers["X-Session-Token"] = session
+                        retry = getattr(client, method)(url, headers=retry_headers, **kwargs)
+                        if retry.status_code < 500:
+                            if not quiet:
+                                console.print(
+                                    "[yellow]API key not accepted by the server here; "
+                                    "used your session token for this request.[/yellow]"
+                                )
+                            response = retry
+
+                return self._handle_response(response, quiet=quiet)
+        except httpx.ConnectError:
+            if not quiet:
+                console.print(
+                    f"[red]Cannot reach Machina API at {self.api_url}. Check your connection.[/red]"
+                )
+            raise SystemExit(1)
+
+    def get(
+        self,
+        path: str,
+        params: Optional[dict] = None,
+        allow_fallback: bool = True,
+        quiet: bool = False,
+    ) -> dict:
+        return self._request("get", path, params=params, allow_fallback=allow_fallback, quiet=quiet)
+
+    def post(
+        self,
+        path: str,
+        json_data: Optional[dict] = None,
+        skip_auth: bool = False,
+        allow_fallback: bool = True,
+        quiet: bool = False,
+    ) -> dict:
+        return self._request(
+            "post",
+            path,
+            json=json_data or {},
+            skip_auth=skip_auth,
+            allow_fallback=allow_fallback,
+            quiet=quiet,
+        )
+
+    def delete(self, path: str, allow_fallback: bool = True, quiet: bool = False) -> dict:
+        return self._request("delete", path, allow_fallback=allow_fallback, quiet=quiet)

{machina_cli-0.4.4 → machina_cli-0.4.7}/src/machina_cli/commands/auth.py

@@ -68,29 +68,44 @@ def do_login(
     # Mode 1: API key
     if api_key:
         store_credential("api_key", api_key)
-        console.print("[green]API key stored successfully.[/green]")
+        console.print("[green]API key stored.[/green]")
 
-        # Verify the key works — try login/session first, fall back to org search
+        # Best-effort identity. CRITICAL: allow_fallback=False so a 5xx never swaps in
+        # the session token (which would report the wrong identity), and the key is
+        # NEVER cleared on failure — verification is informational only. quiet=True so
+        # we own the messaging instead of leaking raw error lines. A 5xx here is
+        # commonly the server faulting on API-key auth, not a bad key.
         client = MachinaClient()
+        label = ""
         try:
-            result = client.get("login/session")
-            user_data = result.get("data", {})
-            name = user_data.get("name", "Unknown")
-            console.print(f"Authenticated as [bold]{name}[/bold]")
+            data = (
+                client.get("login/session", allow_fallback=False, quiet=True).get("data", {}) or {}
+            )
+            label = data.get("name") or data.get("email") or ""
         except SystemExit:
-            # login/session may not support API key auth — try listing orgs instead
             try:
-                result = client.post("user/organizations/search", {
-                    "filters": {}, "page": 1, "page_size": 1, "sorters": ["name", 1],
-                })
-                orgs = result.get("data", [])
+                orgs = (
+                    client.post(
+                        "user/organizations/search",
+                        {"filters": {}, "page": 1, "page_size": 1, "sorters": ["name", 1]},
+                        allow_fallback=False,
+                        quiet=True,
+                    ).get("data", [])
+                    or []
+                )
                 if orgs:
-                    org_name = orgs[0].get("organization_name", orgs[0].get("name", ""))
-                    console.print(f"Authenticated — org: [bold]{org_name}[/bold]")
-                else:
-                    console.print("[green]API key verified.[/green]")
+                    label = orgs[0].get("organization_name") or orgs[0].get("name") or ""
             except SystemExit:
-                console.print("[yellow]API key stored but could not verify. Check the key is valid.[/yellow]")
+                label = ""
+
+        if label:
+            console.print(f"Authenticated as [bold]{label}[/bold]")
+        else:
+            console.print(
+                "[yellow]Key stored, but the server didn't confirm it (the auth endpoints "
+                "may not accept API keys, or returned an error). The key is kept — run a "
+                "command to use it, or set the MACHINA_API_KEY env var.[/yellow]"
+            )
         return
 
     # Mode 3: Username/password (explicit flag)
@@ -146,17 +161,27 @@ def do_login(
 
 @app.command()
 def login(
-    api_key: Optional[str] = typer.Option(None, "--api-key", "-k", help="Authenticate with an API key"),
-    with_credentials: bool = typer.Option(False, "--with-credentials", help="Use username/password instead of browser"),
-    username: Optional[str] = typer.Option(None, "--username", "-u", help="Username (requires --with-credentials)"),
-    password: Optional[str] = typer.Option(None, "--password", "-p", help="Password (requires --with-credentials)"),
+    api_key: Optional[str] = typer.Option(
+        None, "--api-key", "-k", help="Authenticate with an API key"
+    ),
+    with_credentials: bool = typer.Option(
+        False, "--with-credentials", help="Use username/password instead of browser"
+    ),
+    username: Optional[str] = typer.Option(
+        None, "--username", "-u", help="Username (requires --with-credentials)"
+    ),
+    password: Optional[str] = typer.Option(
+        None, "--password", "-p", help="Password (requires --with-credentials)"
+    ),
 ):
     """Login to the Machina platform.
 
     Default: opens browser for Clerk authentication (magic link / SSO).
     Use --api-key for CI/CD, or --with-credentials for username/password.
     """
-    do_login(api_key=api_key, username=username, password=password, with_credentials=with_credentials)
+    do_login(
+        api_key=api_key, username=username, password=password, with_credentials=with_credentials
+    )
 
 
 @app.command()
@@ -168,6 +193,7 @@ def logout():
     # Open browser logout to clear session cookies (Clerk + machina session)
     session_url = get_config("session_url") or "https://session.machina.gg"
     import webbrowser
+
     console.print("[dim]Opening browser to clear session cookies...[/dim]")
     webbrowser.open(f"{session_url}/logout")
     console.print("[green]Logged out completely.[/green]")
@@ -186,11 +212,14 @@ def clear_session():
     # Open browser to clear session cookies on the SESSION app
     session_url = get_config("session_url") or "https://session.machina.gg"
     import webbrowser
+
     console.print("[dim]Opening browser to clear server-side cookies...[/dim]")
     webbrowser.open(f"{session_url}/logout")
 
     console.print()
-    console.print("[bold]Session fully cleared.[/bold] Run [bold #FF5C1F]machina login[/bold #FF5C1F] to re-authenticate.")
+    console.print(
+        "[bold]Session fully cleared.[/bold] Run [bold #FF5C1F]machina login[/bold #FF5C1F] to re-authenticate."
+    )
 
 
 @app.command()
@@ -222,19 +251,25 @@ def whoami(
     auth_method = "API Key" if header_name == "X-Api-Token" else "Session Token"
 
     if json_output:
-        print(json.dumps({
-            "authenticated": True,
-            "name": user_data.get("name"),
-            "email": user_data.get("email"),
-            "user_id": user_data.get("_id", user_data.get("id")),
-            "auth_method": auth_method,
-        }))
+        print(
+            json.dumps(
+                {
+                    "authenticated": True,
+                    "name": user_data.get("name"),
+                    "email": user_data.get("email"),
+                    "user_id": user_data.get("_id", user_data.get("id")),
+                    "auth_method": auth_method,
+                }
+            )
+        )
         return
 
-    console.print(Panel.fit(
-        f"[bold]Name:[/bold] {user_data.get('name', 'N/A')}\n"
-        f"[bold]Email:[/bold] {user_data.get('email', 'N/A')}\n"
-        f"[bold]User ID:[/bold] {user_data.get('_id', user_data.get('id', 'N/A'))}\n"
-        f"[bold]Auth:[/bold] {auth_method}",
-        title="Current User",
-    ))
+    console.print(
+        Panel.fit(
+            f"[bold]Name:[/bold] {user_data.get('name', 'N/A')}\n"
+            f"[bold]Email:[/bold] {user_data.get('email', 'N/A')}\n"
+            f"[bold]User ID:[/bold] {user_data.get('_id', user_data.get('id', 'N/A'))}\n"
+            f"[bold]Auth:[/bold] {auth_method}",
+            title="Current User",
+        )
+    )

machina_cli-0.4.4/src/machina_cli/client.py

@@ -1,101 +0,0 @@
-"""HTTP client for Machina Core API."""
-
-from typing import Optional
-
-import httpx
-from rich.console import Console
-
-from machina_cli.config import _clear_credential, get_api_url, get_credential, resolve_auth_token
-
-console = Console(stderr=True)
-
-TIMEOUT = 30.0
-
-
-class MachinaClient:
-    """HTTP client that handles authentication and error formatting."""
-
-    def __init__(self, api_url: Optional[str] = None):
-        self.api_url = (api_url or get_api_url()).rstrip("/")
-
-    def _headers(self) -> dict:
-        header_name, token = resolve_auth_token()
-        headers = {"Content-Type": "application/json"}
-        if header_name and token:
-            headers[header_name] = token
-        else:
-            console.print("[red]Not authenticated. Run `machina login` first.[/red]")
-            raise SystemExit(1)
-        return headers
-
-    def _handle_response(self, response: httpx.Response) -> dict:
-        data = {}
-        try:
-            data = response.json()
-        except Exception:
-            pass
-
-        # Extract error message from response body if available
-        error_msg = ""
-        if isinstance(data, dict):
-            error = data.get("error", {})
-            if isinstance(error, dict):
-                error_msg = error.get("message", "")
-
-        if response.status_code == 401:
-            console.print(f"[red]{error_msg or 'Session expired.'}[/red]")
-            console.print("[yellow]Run `machina login` to re-authenticate.[/yellow]")
-            raise SystemExit(1)
-        if response.status_code == 403:
-            msg = error_msg or "Permission denied."
-            console.print(f"[red]{msg}[/red]")
-            raise SystemExit(1)
-        if response.status_code == 404:
-            msg = error_msg or "Resource not found."
-            console.print(f"[red]{msg}[/red]")
-            raise SystemExit(1)
-        if response.status_code >= 500:
-            msg = error_msg or "Server error. Try again later."
-            console.print(f"[red]{msg}[/red]")
-            raise SystemExit(1)
-
-        if isinstance(data, dict) and data.get("status") == "error":
-            console.print(f"[red]Error: {error_msg or 'Unknown error'}[/red]")
-            raise SystemExit(1)
-
-        return data
-
-    def _request(self, method: str, path: str, **kwargs) -> dict:
-        """Execute request with automatic API key fallback on 500."""
-        url = f"{self.api_url}/{path.lstrip('/')}"
-        skip_auth = kwargs.pop("skip_auth", False)
-        headers = {"Content-Type": "application/json"} if skip_auth else self._headers()
-        try:
-            with httpx.Client(timeout=TIMEOUT) as client:
-                response = getattr(client, method)(url, headers=headers, **kwargs)
-
-                # If API key returns 500, it may be invalid/missing from Redis.
-                # Clear it and retry with session token if available.
-                if response.status_code >= 500 and headers.get("X-Api-Token"):
-                    if get_credential("session_token"):
-                        console.print(
-                            "[yellow]API key rejected by server. "
-                            "Falling back to session token...[/yellow]"
-                        )
-                        _clear_credential("api_key")
-                        headers = self._headers()
-                        response = getattr(client, method)(url, headers=headers, **kwargs)
-
-                return self._handle_response(response)
-        except httpx.ConnectError:
-            console.print(f"[red]Cannot reach Machina API at {self.api_url}. Check your connection.[/red]")
-            raise SystemExit(1)
-
-    def get(self, path: str, params: Optional[dict] = None) -> dict:
-        return self._request("get", path, params=params)
-
-    def post(self, path: str, json_data: Optional[dict] = None, skip_auth: bool = False) -> dict:
-        return self._request("post", path, json=json_data or {}, skip_auth=skip_auth)
-
-    def delete(self, path: str) -> dict:
-        return self._request("delete", path)