mtrx-cli 0.1.19 → 0.1.21

package/package.json

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

package/src/matrx/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.19"
+__version__ = "0.1.21"

package/src/matrx/cli/launcher.py

@@ -214,6 +214,11 @@ def prepare_routed_setup(
     if route != "matrx":
         return state, changed
 
+    if tool == "claude":
+        env = dict(os.environ if base_env is None else base_env)
+        if _sync_claude_subscription_to_matrx(state, env):
+            changed = True
+
     return state, changed
 
 
@@ -432,6 +437,32 @@ def _workspace_cwd(env: dict[str, str]) -> str:
     return (env.get("PWD") or os.getcwd()).strip()
 
 
+def _capture_git_context(cwd: str | None = None) -> tuple[str, str]:
+    """Return (branch, commit_sha) for the current git repo, or ('', '') on failure."""
+    root = cwd or os.getcwd()
+    branch = ""
+    commit = ""
+    try:
+        r = subprocess.run(
+            ["git", "-C", root, "branch", "--show-current"],
+            capture_output=True, text=True, timeout=2, check=False,
+        )
+        if r.returncode == 0:
+            branch = r.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    try:
+        r = subprocess.run(
+            ["git", "-C", root, "rev-parse", "--short", "HEAD"],
+            capture_output=True, text=True, timeout=2, check=False,
+        )
+        if r.returncode == 0:
+            commit = r.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return branch, commit
+
+
 def _resolve_matrx_context_overrides(
     state: dict,
     env: dict[str, str],
@@ -506,6 +537,11 @@ def _build_codex_env(
             header_parts.append(f'"X-Matrx-Group" = "{group_id}"')
         if project_id:
             header_parts.append(f'"X-Matrx-Project-Id" = "{project_id}"')
+        _git_branch, _git_commit = _capture_git_context(_workspace_cwd(env))
+        if _git_branch:
+            header_parts.append(f'"X-Matrx-Branch" = "{_git_branch}"')
+        if _git_commit:
+            header_parts.append(f'"X-Matrx-Commit" = "{_git_commit}"')
         if env_b64:
             header_parts.append(f'"X-Matrx-Env" = "{env_b64}"')
         headers_str = ", ".join(header_parts)
@@ -555,19 +591,36 @@ def _build_gemini_env(
     if route == "matrx":
         if not mx_key:
             raise ValueError("No Matrx key available. Run: mtrx login matrx --key mx_... or set MTRX_KEY")
-        
+
         # Clear existing Gemini config to force proxy usage
         env.pop("MTRX_KEY", None)
-        
+
+        group_id, project_id = _resolve_matrx_context_overrides(state, env)
+        session_id = str(uuid.uuid4())
+        runtime_agent_id = (
+            (orchestration or {}).get("agent_id")
+            or _runtime_agent_basename("gemini")[0]
+        )
+
+        # Build a project-aware proxy base URL so the proxy can identify the project
+        # even though Gemini CLI doesn't support custom request headers via env vars.
+        # We append matrx context as query params which the proxy reads.
+        proxy_base_with_ctx = proxy_base
+        ctx_params: list[str] = []
+        if project_id:
+            ctx_params.append(f"mtrx_project={project_id}")
+        if session_id:
+            ctx_params.append(f"mtrx_session={session_id}")
+        if runtime_agent_id:
+            ctx_params.append(f"mtrx_agent={runtime_agent_id}")
+        if ctx_params:
+            proxy_base_with_ctx = f"{proxy_base}?{'&'.join(ctx_params)}"
+
         # Set Proxy Config
-        env["GOOGLE_GEMINI_BASE_URL"] = proxy_base
-        env["GEMINI_API_ENDPOINT"] = proxy_base
+        env["GOOGLE_GEMINI_BASE_URL"] = proxy_base_with_ctx
+        env["GEMINI_API_ENDPOINT"] = proxy_base_with_ctx
         env["GOOGLE_API_KEY"] = mx_key
-        
-        # Matrx-specific headers (if supported by the tool, or for our own tracking)
-        # Note: Standard Gemini CLI might not support custom headers via env vars easily.
-        # We rely on the Base URL routing to Matrx proxy which handles the logic.
-        
+
         return env, matrx_auth_source
 
     # Direct route: clear any matrx-managed env vars
@@ -632,6 +685,11 @@ def _build_claude_env(
             custom_headers += f"\nx-matrx-group: {group_id}"
         if project_id:
             custom_headers += f"\nx-matrx-project-id: {project_id}"
+        _git_branch, _git_commit = _capture_git_context(_workspace_cwd(env))
+        if _git_branch:
+            custom_headers += f"\nx-matrx-branch: {_git_branch}"
+        if _git_commit:
+            custom_headers += f"\nx-matrx-commit: {_git_commit}"
         if env_b64:
             custom_headers += f"\nx-matrx-env: {env_b64}"
         env["ANTHROPIC_CUSTOM_HEADERS"] = custom_headers
@@ -709,14 +767,14 @@ def _build_orchestration_metadata(
     }
 
 
-def _best_effort_register_cli_agent(orchestration: dict) -> None:
+def _best_effort_register_cli_agent(orchestration: dict) -> bool:
     if not orchestration:
-        return
+        return False
     base_url = (orchestration.get("base_url") or "").rstrip("/")
     matrx_key = (orchestration.get("matrx_key") or "").strip()
     agent_id = (orchestration.get("agent_id") or "").strip()
     if not base_url or not matrx_key or not agent_id:
-        return
+        return False
 
     payload = {
         "agent_id": agent_id,
@@ -743,10 +801,11 @@ def _best_effort_register_cli_agent(orchestration: dict) -> None:
                 json=payload,
             )
         if response.status_code in {404, 401, 403}:
-            return
+            return False
         response.raise_for_status()
+        return True
     except httpx.HTTPError:
-        return
+        return False
 
 
 def _heartbeat_cli_agent(orchestration: dict, stop_event) -> None:
@@ -773,6 +832,14 @@ def _heartbeat_cli_agent(orchestration: dict, stop_event) -> None:
                     f"{base_url}/v1/orchestration/agents/{agent_id}/heartbeat",
                     headers=headers,
                 )
+            if response.status_code == 404:
+                if not _best_effort_register_cli_agent(orchestration):
+                    return
+                with httpx.Client(timeout=5) as client:
+                    response = client.patch(
+                        f"{base_url}/v1/orchestration/agents/{agent_id}/heartbeat",
+                        headers=headers,
+                    )
             if response.status_code in {404, 401, 403}:
                 return
         except httpx.HTTPError:
@@ -839,16 +906,18 @@ def _validate_gemini_launch_plan(plan: LaunchPlan, state: dict) -> None:
         return
 
     expected_base_url = ensure_v1_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
-    
+
     base_url = (plan.env.get("GOOGLE_GEMINI_BASE_URL") or "").strip()
     if not base_url:
-         # Try the other one
-         base_url = (plan.env.get("GEMINI_API_ENDPOINT") or "").strip()
+        base_url = (plan.env.get("GEMINI_API_ENDPOINT") or "").strip()
 
     if not base_url:
         raise ValueError("Gemini Matrx route is missing GOOGLE_GEMINI_BASE_URL or GEMINI_API_ENDPOINT")
-        
-    if base_url != expected_base_url:
+
+    # Strip query params before comparing (project_id context may be appended as ?mtrx_project=...)
+    base_url_no_qs = base_url.split("?")[0].rstrip("/")
+    expected_no_qs = expected_base_url.rstrip("/")
+    if base_url_no_qs != expected_no_qs:
         raise ValueError(
             "Gemini Matrx route must use the Matrx /v1 base URL. "
             f"Got: {base_url}"
@@ -921,13 +990,19 @@ def describe_launch_plan(plan: LaunchPlan, state: dict) -> list[str]:
 
     if plan.tool == "gemini":
         base_url = ensure_v1_url(state.get("auth", {}).get("matrx", {}).get("base_url"))
-        return [
+        _, project_id = _resolve_matrx_context_overrides(state, dict(plan.env))
+        lines = [
             "Launching gemini via Matrx",
             f"  base_url: {base_url}",
             f"  auth_source: {plan.auth_source}",
             "  runtime_route: env injection",
             "  persistent_route: disabled",
         ]
+        if project_id:
+            lines.append(f"  project_id: {project_id}")
+        else:
+            lines.append("  project_id: (from API key scope)")
+        return lines
 
     return []
 

package/src/matrx/cli/main.py

@@ -82,6 +82,8 @@ def main(argv: list[str] | None = None) -> int:
         from matrx.cli.bootstrap import run_init
         run_init()
         return 0
+    if args.command == "project":
+        return _cmd_project(args)
 
     parser.print_help()
     return 1
@@ -124,6 +126,17 @@ def _build_parser() -> argparse.ArgumentParser:
     gemini = subparsers.add_parser("gemini")
     gemini.add_argument("--route", choices=["direct", "matrx"])
 
+    project = subparsers.add_parser("project", help="Manage Matrx projects")
+    project_sub = project.add_subparsers(dest="project_command")
+    project_sub.add_parser("list", help="List projects in your org")
+    project_sub.add_parser("current", help="Show active project for this workspace")
+    project_switch = project_sub.add_parser("switch", help="Bind this workspace to a project")
+    project_switch.add_argument("name", help="Project name, slug, or ID")
+    project_create = project_sub.add_parser("create", help="Create a new project")
+    project_create.add_argument("name", help="Project name")
+    project_create.add_argument("--description", help="Optional description")
+    project_sub.add_parser("init", help="Link this git repo to a Matrx project")
+
     cursor = subparsers.add_parser("cursor")
     cursor.add_argument("--route", choices=["direct", "matrx"])
     cursor.add_argument("--status", action="store_true", help="Check proxy status")
@@ -453,10 +466,13 @@ def _cmd_login(args) -> int:
 
     key = (args.key or "").strip()
     if provider == "matrx":
+        url_changed = False
         if args.base_url:
             state["auth"]["matrx"]["base_url"] = args.base_url.strip()
+            url_changed = True
         if args.app_url:
             state["auth"]["matrx"]["app_url"] = args.app_url.strip()
+            url_changed = True
         elif not state["auth"]["matrx"].get("app_url"):
             state["auth"]["matrx"]["app_url"] = ensure_app_url(
                 None,
@@ -471,13 +487,14 @@ def _cmd_login(args) -> int:
             except ValueError as exc:
                 print(str(exc), file=sys.stderr)
                 return 1
-            if changed:
+            if changed or url_changed:
                 path = save_state(state)
                 print(f"Saved {args.provider} credentials to {path}")
                 print(f"Matrx base URL: {ensure_v1_url(state['auth']['matrx']['base_url'])}")
                 return 0
-            print("Matrx login did not change the current state", file=sys.stderr)
-            return 1
+            if not url_changed:
+                print("Matrx login did not change the current state", file=sys.stderr)
+                return 1
 
     if not key:
         print("--key is required for this login command", file=sys.stderr)
@@ -558,16 +575,32 @@ def _restore_cursor_if_needed() -> None:
 def _cmd_status() -> int:
     state = load_state()
     auth = state["auth"]
+
+    # Show active project for this workspace
+    workspace_binding = get_workspace_binding(state, cwd=os.environ.get("PWD") or os.getcwd()) or {}
+    active_project_id = (
+        (os.environ.get("MTRX_PROJECT_ID") or "").strip()
+        or (workspace_binding.get("project_id") or "").strip()
+    )
+    if active_project_id:
+        source = "env" if (os.environ.get("MTRX_PROJECT_ID") or "").strip() else "workspace"
+        print(f"Active project: {active_project_id} [{source}]")
+    else:
+        print("Active project: none (run: mtrx project switch <name>)")
+
     print("Defaults:")
-    print(f"  codex: {_default_route_label(configured_route(state, 'codex'))}")
-    print(f"  claude: {_default_route_label(configured_route(state, 'claude'))}")
-    print(f"  gemini: {_default_route_label(configured_route(state, 'gemini'))}")
-    print(f"  cursor: {_default_route_label(configured_route(state, 'cursor'))}")
+    for tool in ("codex", "claude", "gemini", "cursor"):
+        route = configured_route(state, tool) or "not set"
+        print(f"  {tool}: {route}")
     print("Auth:")
+    config_base = auth["matrx"].get("base_url")
+    env_base = (os.environ.get("MATRX_BASE_URL") or "").strip()
+    effective_base = ensure_v1_url(env_base or config_base)
+    base_source = "MATRX_BASE_URL env" if env_base else "config"
     print(
         "  matrx: "
         f"{mask_secret(auth['matrx'].get('key'))} "
-        f"({ensure_v1_url(auth['matrx'].get('base_url'))})"
+        f"({effective_base}) [{base_source}]"
     )
     print(f"  matrx app: {ensure_app_url(auth['matrx'].get('app_url'), base_url=auth['matrx'].get('base_url'))}")
     print(f"  openai: {mask_secret(auth['openai'].get('key'))}")
@@ -595,6 +628,24 @@ def _cmd_status() -> int:
     proxy_running = is_proxy_running()
     print(f"  cursor proxy: {'running' if proxy_running else 'not running'}")
 
+    # Matrx API proxy health (when base_url configured)
+    base_url = auth["matrx"].get("base_url")
+    if base_url:
+        try:
+            health_url = f"{ensure_root_url(base_url).rstrip('/')}/health/wiring"
+            with httpx.Client(timeout=5) as client:
+                resp = client.get(health_url)
+            if resp.status_code == 200:
+                data = resp.json()
+                wiring = "ok" if data.get("proxy_wiring_ok") else "incomplete"
+                kv = data.get("key_vault", {})
+                enc = "configured" if kv.get("encryption_configured") else "not configured"
+                print(f"  matrx proxy: reachable (wiring={wiring}, key_vault={enc})")
+            else:
+                print(f"  matrx proxy: HTTP {resp.status_code}")
+        except Exception as exc:
+            print(f"  matrx proxy: unreachable ({exc})")
+
     print("Executables:")
     print(f"  codex: {find_executable('codex') or 'not found'}")
     print(f"  claude: {find_executable('claude') or 'not found'}")
@@ -800,6 +851,35 @@ def _cmd_doctor() -> int:
         else:
             print(f"[warn] {tool} native config not configured")
 
+    # Proxy health check — when using matrx route, verify server is reachable
+    base_url = state.get("auth", {}).get("matrx", {}).get("base_url")
+    mx_key = matrx_key or workspace_matrx_key or env_matrx_key
+    if base_url and mx_key:
+        try:
+            health_url = f"{ensure_root_url(base_url).rstrip('/')}/health/wiring"
+            with httpx.Client(timeout=10) as client:
+                resp = client.get(health_url)
+            if resp.status_code == 200:
+                data = resp.json()
+                if data.get("proxy_wiring_ok"):
+                    print("[ok] Matrx proxy reachable and wired")
+                else:
+                    comps = data.get("components", {})
+                    missing = [k for k, v in comps.items() if not v]
+                    print(f"[warn] Matrx proxy incomplete: missing {missing}")
+                kv = data.get("key_vault", {})
+                if not kv.get("encryption_configured"):
+                    print(
+                        "[warn] Key vault encryption not configured on server — "
+                        "provider keys may fail to decrypt; set KEY_VAULT_ENCRYPTION_KEY"
+                    )
+            else:
+                print(f"[warn] Matrx proxy health check failed: {resp.status_code}")
+        except httpx.HTTPError as exc:
+            print(f"[warn] Matrx proxy unreachable: {exc}")
+        except Exception as exc:
+            print(f"[warn] Matrx proxy check failed: {exc}")
+
     return 1 if failures else 0
 
 
@@ -976,5 +1056,29 @@ def _default_route_label(route: str | None) -> str:
     return route or "unset"
 
 
+def _cmd_project(args) -> int:
+    from matrx.cli.project_cmds import cmd_list, cmd_current, cmd_switch, cmd_create, cmd_init
+
+    sub = getattr(args, "project_command", None)
+    if sub == "list":
+        return cmd_list(args)
+    if sub == "current":
+        return cmd_current(args)
+    if sub == "switch":
+        return cmd_switch(args)
+    if sub == "create":
+        return cmd_create(args)
+    if sub == "init":
+        return cmd_init(args)
+
+    print("Usage: mtrx project <list|current|switch|create|init>", file=sys.stderr)
+    print("  list            List all projects in your org")
+    print("  current         Show active project for this workspace")
+    print("  switch <name>   Bind this workspace to a project")
+    print("  create <name>   Create a new project")
+    print("  init            Link this git repo to a Matrx project")
+    return 1
+
+
 if __name__ == "__main__":
     raise SystemExit(main())