mtrx-cli 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtrx-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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.5"
+__version__ = "0.1.7"

package/src/matrx/cli/launcher.py

@@ -170,13 +170,6 @@ def prepare_routed_setup(
         changed = True
     if route == "matrx" and _persist_workspace_binding_from_env(state, env):
         changed = True
-    if route == "matrx" and tool == "claude":
-        mx_key, _ = _resolve_matrx_route_key(state, env)
-        if _approve_claude_custom_api_key(mx_key):
-            changed = True
-        if _sync_claude_subscription_to_matrx(state, env):
-            changed = True
-
     if _sync_tool_route_config(state, tool=tool, route=route):
         changed = True
 
@@ -221,7 +214,16 @@ def codex_auth_path() -> Path:
 
 def claude_oauth_available() -> bool:
     token = read_claude_oauth_token()
-    return bool(token)
+    if token:
+        return True
+    state = _read_claude_app_state()
+    oauth_account = state.get("oauthAccount")
+    if not isinstance(oauth_account, dict):
+        return False
+    return bool(
+        (oauth_account.get("accountUuid") or "").strip()
+        or (oauth_account.get("emailAddress") or "").strip()
+    )
 
 
 def read_claude_oauth_token() -> str | None:
@@ -491,8 +493,8 @@ def _build_claude_env(
         env.pop("MATRX_CLAUDE_MODE", None)
         env["MATRX_BASE_URL"] = proxy_root
         env["MATRX_API_KEY"] = mx_key
-        env["ANTHROPIC_BASE_URL"] = proxy_base
-        env["ANTHROPIC_API_KEY"] = mx_key
+        env["ANTHROPIC_BASE_URL"] = proxy_root
+        env.pop("ANTHROPIC_API_KEY", None)
         group_id, project_id = _resolve_matrx_context_overrides(state, env)
         session_id = str(uuid.uuid4())
         # Evolutionary scaffolding: env snapshot for AI context injection
@@ -500,6 +502,7 @@ def _build_claude_env(
         env_b64 = base64.b64encode(json.dumps(env_snap).encode()).decode() if env_snap else ""
         custom_headers = "\n".join(
             [
+                f"x-matrx-key: {mx_key}",
                 "x-matrx-agent-id: claude-cli",
                 "x-matrx-provider: claude_code",
                 f"x-matrx-session-id: {session_id}",
@@ -558,7 +561,7 @@ def _validate_claude_launch_plan(plan: LaunchPlan, state: dict) -> None:
         return
 
     base_url = (plan.env.get("ANTHROPIC_BASE_URL") or "").strip()
-    expected_base_url = ensure_v1_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
+    expected_base_url = ensure_root_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
     if not base_url:
         raise ValueError("Claude Matrx route is missing ANTHROPIC_BASE_URL")
     if base_url != expected_base_url:
@@ -571,14 +574,12 @@ def _validate_claude_launch_plan(plan: LaunchPlan, state: dict) -> None:
     if not mx_key.startswith("mx_"):
         raise ValueError("Claude Matrx route is missing a valid MATRX_API_KEY")
 
-    anthropic_key = (plan.env.get("ANTHROPIC_API_KEY") or "").strip()
-    if anthropic_key != mx_key:
-        raise ValueError("Claude Matrx route must set ANTHROPIC_API_KEY to the same mx_ key as MATRX_API_KEY")
-
     custom_headers = (plan.env.get("ANTHROPIC_CUSTOM_HEADERS") or "").strip()
     if not custom_headers:
         raise ValueError("Claude Matrx route is missing ANTHROPIC_CUSTOM_HEADERS")
     lowered_headers = custom_headers.lower()
+    if "x-matrx-key:" not in lowered_headers:
+        raise ValueError("Claude Matrx route is missing ANTHROPIC_CUSTOM_HEADERS with X-Matrx-Key")
     if "x-matrx-session-id:" not in lowered_headers:
         raise ValueError("Claude Matrx route is missing ANTHROPIC_CUSTOM_HEADERS with X-Matrx-Session-Id")
     if "x-matrx-provider: claude_code" not in lowered_headers:
@@ -588,6 +589,8 @@ def _validate_claude_launch_plan(plan: LaunchPlan, state: dict) -> None:
 
     if plan.env.get("ANTHROPIC_AUTH_TOKEN"):
         raise ValueError("Claude Matrx route should not set ANTHROPIC_AUTH_TOKEN")
+    if plan.env.get("ANTHROPIC_API_KEY"):
+        raise ValueError("Claude Matrx route should not set ANTHROPIC_API_KEY")
 
 
 def _validate_codex_launch_plan(plan: LaunchPlan, state: dict) -> None:
@@ -637,15 +640,14 @@ def describe_launch_plan(plan: LaunchPlan, state: dict) -> list[str]:
         ]
 
     if plan.tool == "claude":
-        base_url = ensure_v1_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
+        base_url = ensure_root_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
         custom_headers = (plan.env.get("ANTHROPIC_CUSTOM_HEADERS") or "").strip()
-        anthropic_key = (plan.env.get("ANTHROPIC_API_KEY") or "").strip()
         return [
             "Launching claude via Matrx",
             f"  base_url: {base_url or DEFAULT_MATRX_BASE_URL}",
             f"  auth_source: {plan.auth_source}",
             f"  custom_headers_present: {bool(custom_headers)}",
-            f"  proxy_key_present: {anthropic_key.startswith('mx_')}",
+            f"  proxy_key_present: {'x-matrx-key:' in custom_headers.lower()}",
             f"  subscription_token_available: {bool(_resolve_claude_subscription_token(state))}",
             "  runtime_route: env injection",
             "  persistent_route: disabled",

package/src/matrx/cli/main.py

@@ -7,7 +7,6 @@ import os
 import subprocess
 import sys
 import threading
-import time
 import urllib.parse
 import webbrowser
 
@@ -263,103 +262,22 @@ 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):
+    if claude_oauth_available():
         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"
+            "Claude login required. Run: claude auth login"
         )
 
-    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")
+    print("Claude login required.")
+    if not _prompt_yes_no("Run `claude auth login` now?", default=True):
+        raise ValueError("Claude login cancelled")
 
-    _run_claude_subscription_browser_login(state)
+    executable = find_executable("claude") or "claude"
+    result = subprocess.run([executable, "auth", "login"], check=False)
+    if result.returncode != 0 or not claude_oauth_available():
+        raise ValueError("Claude login did not complete successfully")
 
     return state, False