mtrx-cli 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtrx-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "MATRX CLI for routing Codex and Claude through Matrx",
   "homepage": "https://mtrx.so",
   "repository": {

package/src/matrx/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.3"
+__version__ = "0.1.5"

package/src/matrx/cli/main.py

@@ -7,6 +7,7 @@ import os
 import subprocess
 import sys
 import threading
+import time
 import urllib.parse
 import webbrowser
 
@@ -262,6 +263,107 @@ def _complete_codex_login() -> None:
         raise ValueError("Codex login did not complete successfully")
 
 
+def _resolve_matrx_launch_key(state: dict, env: dict[str, str] | None = None) -> str:
+    env = env or os.environ
+    env_key = (env.get("MTRX_KEY") or "").strip()
+    if env_key:
+        return env_key
+    workspace_binding = get_workspace_binding(state, cwd=env.get("PWD") or os.getcwd()) or {}
+    workspace_key = (workspace_binding.get("matrx_key") or "").strip()
+    if workspace_key:
+        return workspace_key
+    return (state.get("auth", {}).get("matrx", {}).get("key") or "").strip()
+
+
+def _matrx_request_context(state: dict) -> tuple[str, dict[str, str]]:
+    mx_key = _resolve_matrx_launch_key(state)
+    if not mx_key.startswith("mx_"):
+        raise ValueError("Matrx login required before connecting Claude Code")
+    base_url = ensure_root_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
+    return base_url, {"X-Matrx-Key": mx_key}
+
+
+def _list_matrx_subscriptions(state: dict) -> list[dict]:
+    base_url, headers = _matrx_request_context(state)
+    try:
+        with httpx.Client(timeout=15) as client:
+            response = client.get(f"{base_url.rstrip('/')}/v1/subscriptions", headers=headers)
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        detail = exc.response.text.strip() or f"HTTP {exc.response.status_code}"
+        raise ValueError(f"Could not query Matrx subscriptions: {detail}") from exc
+    except httpx.HTTPError as exc:
+        raise ValueError(f"Could not query Matrx subscriptions: {exc}") from exc
+
+    payload = response.json()
+    subscriptions = payload.get("subscriptions")
+    if not isinstance(subscriptions, list):
+        return []
+    return [entry for entry in subscriptions if isinstance(entry, dict)]
+
+
+def _has_server_claude_subscription(state: dict) -> bool:
+    try:
+        subscriptions = _list_matrx_subscriptions(state)
+    except ValueError:
+        return False
+    return any((entry.get("provider") or "").strip() == "claude_code" for entry in subscriptions)
+
+
+def _run_claude_subscription_browser_login(state: dict) -> None:
+    base_url, headers = _matrx_request_context(state)
+    try:
+        with httpx.Client(timeout=15) as client:
+            response = client.get(
+                f"{base_url.rstrip('/')}/v1/subscriptions/claude-code/authorize",
+                headers=headers,
+            )
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        detail = exc.response.text.strip() or f"HTTP {exc.response.status_code}"
+        raise ValueError(f"Could not start Claude Code connection: {detail}") from exc
+    except httpx.HTTPError as exc:
+        raise ValueError(f"Could not start Claude Code connection: {exc}") from exc
+
+    payload = response.json()
+    auth_url = (payload.get("auth_url") or "").strip()
+    if not auth_url:
+        raise ValueError("Matrx did not return a Claude Code authorization URL")
+
+    print(f"Open this URL to connect Claude Code to Matrx:\n  {auth_url}")
+    webbrowser.open(auth_url)
+
+    deadline = time.monotonic() + 300
+    while time.monotonic() < deadline:
+        if _has_server_claude_subscription(state):
+            return
+        time.sleep(2)
+
+    raise ValueError("Claude Code connection timed out")
+
+
+def _complete_claude_login(state: dict) -> tuple[dict, bool]:
+    token = (read_claude_oauth_token() or "").strip()
+    imported = (state.get("auth", {}).get("claude_code", {}).get("oauth_token") or "").strip()
+    if token or imported:
+        return state, False
+    if _has_server_claude_subscription(state):
+        return state, False
+    if not _is_interactive_terminal():
+        raise ValueError(
+            "Claude provider connection required. "
+            "Run `mtrx login claude-code --import` or rerun interactively to connect in the browser"
+        )
+
+    print("Claude provider connection required.")
+    if not _prompt_yes_no("Open the browser-based Claude Code connection flow now?", default=True):
+        raise ValueError("Claude connection cancelled")
+
+    _run_claude_subscription_browser_login(state)
+
+    return state, False
+
+
 def _maybe_promote_direct_route(state: dict, tool: str, route: str | None) -> tuple[str | None, bool]:
     if route is not None:
         return route, False
@@ -290,7 +392,11 @@ def _cmd_login(args) -> int:
         token = read_claude_oauth_token()
         if not token:
             print(
-                f"No Claude OAuth token found at {claude_credentials_path()}",
+                (
+                    f"No Claude OAuth token found at {claude_credentials_path()}. "
+                    "If your Claude install no longer writes that file, use the browser-based "
+                    "`mtrx claude` flow instead, or run `claude setup-token` and import that token."
+                ),
                 file=sys.stderr,
             )
             return 1
@@ -569,6 +675,9 @@ def _cmd_launch(tool: str, route: str | None, remainder: list[str]) -> int:
             auth_changed = auth_changed or login_changed
             if tool == "codex":
                 _complete_codex_login()
+            if tool == "claude":
+                state, login_changed = _complete_claude_login(state)
+                auth_changed = auth_changed or login_changed
         initialized = initialize_first_launch_route(state, tool, route)
         state, changed = prepare_routed_setup(
             state,