mtrx-cli 0.1.0 → 0.1.1

package/package.json

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

package/src/matrx/cli/launcher.py

@@ -123,7 +123,7 @@ def build_launch_plan(
         raise ValueError(f"{tool} executable not found in PATH")
 
     route = resolve_route(state, tool, route_override)
-    env = dict(base_env or os.environ)
+    env = dict(os.environ if base_env is None else base_env)
     auth_source = ""
     launch_args = list(passthrough_args or [])
 
@@ -164,7 +164,7 @@ def prepare_routed_setup(
     """
     route = resolve_route(state, tool, route_override)
     changed = False
-    env = dict(base_env or os.environ)
+    env = dict(os.environ if base_env is None else base_env)
     if route == "matrx" and _ensure_matrx_auth(state, env=env):
         changed = True
     if route == "matrx" and _persist_workspace_binding_from_env(state, env):
@@ -376,6 +376,7 @@ def _build_claude_env(
     proxy_base = ensure_root_url(matrx.get("base_url"))
     mx_key, matrx_auth_source = _resolve_matrx_route_key(state, env)
     direct_key = (anthropic.get("key") or "").strip()
+    oauth_mode = _claude_effective_oauth_mode(state, env)
 
     if route == "matrx":
         if not mx_key:
@@ -410,7 +411,7 @@ def _build_claude_env(
         # forward it to Anthropic without confusing the matrx key with a provider key.
         env["ANTHROPIC_CUSTOM_HEADERS"] = custom_headers
         env.pop("ANTHROPIC_AUTH_TOKEN", None)
-        if _claude_uses_oauth(state):
+        if oauth_mode:
             # OAuth token flows through natively via Authorization: Bearer sk-ant-oat01-*
             env.pop("ANTHROPIC_API_KEY", None)
         else:
@@ -476,10 +477,7 @@ 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 _claude_uses_oauth(state):
-        oauth_token = read_claude_oauth_token() or (state.get("auth", {}).get("claude_code", {}).get("oauth_token") or "").strip()
-        if not oauth_token:
-            raise ValueError("Claude OAuth was selected but no Claude OAuth token is available. Run: mtrx login claude-code --import")
+    if _claude_effective_oauth_mode(state, plan.env):
         if plan.env.get("ANTHROPIC_API_KEY"):
             raise ValueError("Claude Matrx OAuth route should not set ANTHROPIC_API_KEY")
 
@@ -538,7 +536,7 @@ def describe_launch_plan(plan: LaunchPlan, state: dict) -> list[str]:
             "Launching claude via Matrx",
             f"  base_url: {base_url or DEFAULT_MATRX_BASE_URL}",
             f"  auth_source: {plan.auth_source}",
-            f"  oauth_mode: {_claude_uses_oauth(state)}",
+            f"  oauth_mode: {_claude_effective_oauth_mode(state, plan.env)}",
             f"  custom_headers_present: {bool(custom_headers)}",
             f"  api_key_present: {api_key_present}",
         ]
@@ -601,6 +599,15 @@ def _claude_uses_oauth(state: dict) -> bool:
     return bool(imported)
 
 
+def _claude_effective_oauth_mode(state: dict, env: dict[str, str] | None = None) -> bool:
+    requested = ((env or {}).get("MATRX_CLAUDE_MODE") or "").strip().lower()
+    if requested == "oauth":
+        return True
+    if requested == "api-key":
+        return False
+    return _claude_uses_oauth(state)
+
+
 def _sync_tool_route_config(state: dict, *, tool: str, route: str) -> bool:
     if tool == "claude":
         return _cleanup_claude_managed_config(state)

package/src/matrx/cli/main.py

@@ -10,6 +10,8 @@ import threading
 import urllib.parse
 import webbrowser
 
+import httpx
+
 from matrx.cli.launcher import (
     prepare_routed_setup,
     build_launch_plan,
@@ -52,6 +54,8 @@ def main(argv: list[str] | None = None) -> int:
         return _cmd_status()
     if args.command == "doctor":
         return _cmd_doctor()
+    if args.command == "personal":
+        return _cmd_personal(args)
     if args.command in {"codex", "claude"}:
         return _cmd_launch(args.command, args.route, remainder)
 
@@ -79,6 +83,11 @@ def _build_parser() -> argparse.ArgumentParser:
     subparsers.add_parser("status")
     subparsers.add_parser("doctor")
 
+    personal = subparsers.add_parser("personal")
+    personal_subparsers = personal.add_subparsers(dest="personal_command")
+    optimize = personal_subparsers.add_parser("optimize")
+    optimize.add_argument("mode", choices=["on", "off", "status"])
+
     codex = subparsers.add_parser("codex")
     codex.add_argument("--route", choices=["direct", "matrx"])
 
@@ -379,6 +388,100 @@ def _cmd_status() -> int:
     return 0
 
 
+def _personal_matrx_key(state: dict) -> str:
+    return (state.get("auth", {}).get("matrx", {}).get("key") or "").strip()
+
+
+def _matrx_api_json(
+    state: dict,
+    *,
+    method: str,
+    path: str,
+    key: str,
+    json_body: dict | None = None,
+) -> dict:
+    base_url = ensure_root_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
+    url = f"{base_url.rstrip('/')}/v1{path}"
+    headers = {"X-Matrx-Key": key}
+    if json_body is not None:
+        headers["Content-Type"] = "application/json"
+
+    try:
+        with httpx.Client(timeout=15) as client:
+            response = client.request(method, url, headers=headers, json=json_body)
+    except httpx.HTTPError as exc:
+        raise ValueError(f"Matrx API request failed: {exc}") from exc
+
+    if response.status_code >= 400:
+        detail = response.text.strip() or response.reason_phrase
+        raise ValueError(f"Matrx API error ({response.status_code}) for {path}: {detail}")
+
+    if response.status_code == 204 or not response.content:
+        return {}
+    return response.json()
+
+
+def _resolve_personal_policy_target(state: dict, *, key: str) -> tuple[dict, dict]:
+    context = _matrx_api_json(state, method="GET", path="/auth/context", key=key)
+    project_id = (context.get("project_id") or "").strip()
+    group_id = (context.get("group_id") or "").strip()
+    if not project_id:
+        raise ValueError("Saved Matrx key is not project-scoped; personal optimization is unavailable")
+    if not group_id:
+        raise ValueError("No default personal group found for the current Matrx project")
+
+    group = _matrx_api_json(state, method="GET", path=f"/groups/{group_id}", key=key)
+    policy_id = (group.get("policy_id") or "").strip()
+    if not policy_id:
+        raise ValueError("Default personal group has no optimization policy attached")
+
+    policy = _matrx_api_json(state, method="GET", path=f"/policies/{policy_id}", key=key)
+    return context, policy
+
+
+def _cmd_personal_optimize(args) -> int:
+    state = load_state()
+    key = _personal_matrx_key(state)
+    if not key:
+        print("Personal Matrx login required. Run: mtrx login matrx", file=sys.stderr)
+        return 1
+
+    try:
+        context, policy = _resolve_personal_policy_target(state, key=key)
+        mode = args.mode
+        if mode == "status":
+            print(f"Personal optimization: {policy.get('mode', 'unknown')}")
+            print(f"  project: {context.get('project_id') or '-'}")
+            print(f"  group: {context.get('group_id') or '-'}")
+            print(f"  policy: {policy.get('id') or '-'}")
+            return 0
+
+        target_mode = "optimize" if mode == "on" else "observe"
+        updated = _matrx_api_json(
+            state,
+            method="PATCH",
+            path=f"/policies/{policy['id']}",
+            key=key,
+            json_body={"mode": target_mode},
+        )
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+    print(f"Personal optimization: {updated.get('mode', target_mode)}")
+    print(f"  project: {context.get('project_id') or '-'}")
+    print(f"  group: {context.get('group_id') or '-'}")
+    print(f"  policy: {updated.get('id') or policy.get('id') or '-'}")
+    return 0
+
+
+def _cmd_personal(args) -> int:
+    if args.personal_command == "optimize":
+        return _cmd_personal_optimize(args)
+    print("Use: mtrx personal optimize <on|off|status>", file=sys.stderr)
+    return 1
+
+
 def _cmd_doctor() -> int:
     state = load_state()
     failures = 0