mtrx-cli 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtrx-cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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.18"
+__version__ = "0.1.19"

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],
@@ -475,13 +506,16 @@ def _build_codex_env(
     proxy_base = ensure_v1_url(matrx.get("base_url"))
     mx_key, matrx_auth_source = _resolve_matrx_route_key(state, env)
     direct_key = (openai.get("key") or "").strip()
+    env_openai_key = (env.get("OPENAI_API_KEY") or "").strip()
 
     if route == "matrx":
         if not mx_key:
             raise ValueError("No Matrx key available. Run: mtrx login matrx --key mx_... or set MTRX_KEY")
-        access_token = read_codex_access_token()
-        if not access_token:
-            raise ValueError("Codex login required. Run: codex login")
+        provider_bearer = env_openai_key or direct_key or read_codex_access_token()
+        if not provider_bearer:
+            raise ValueError(
+                "Codex login required. Run: codex login or configure an OpenAI API key."
+            )
         for key in MATRX_ENV_KEYS:
             env.pop(key, None)
         env_snap = _capture_env_snapshot()
@@ -493,7 +527,7 @@ def _build_codex_env(
             or _runtime_agent_basename("codex")[0]
         )
         header_parts = [
-            f'"Authorization" = "Bearer {access_token}"',
+            f'"Authorization" = "Bearer {provider_bearer}"',
             f'"X-Matrx-Key" = "{mx_key}"',
             f'"X-Matrx-Agent-Id" = "{runtime_agent_id}"',
             '"X-Matrx-Provider" = "codex"',
@@ -552,19 +586,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
@@ -706,14 +757,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,
@@ -740,10 +791,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:
@@ -770,6 +822,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:
@@ -836,16 +896,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}"
@@ -918,13 +980,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

@@ -78,6 +78,12 @@ def main(argv: list[str] | None = None) -> int:
         return _cmd_launch(args.command, args.route, remainder)
     if args.command == "cursor":
         return _cmd_cursor(args)
+    if args.command == "init":
+        from matrx.cli.bootstrap import run_init
+        run_init()
+        return 0
+    if args.command == "project":
+        return _cmd_project(args)
 
     parser.print_help()
     return 1
@@ -104,6 +110,7 @@ def _build_parser() -> argparse.ArgumentParser:
     subparsers.add_parser("version")
     subparsers.add_parser("status")
     subparsers.add_parser("doctor")
+    subparsers.add_parser("init", help="Initialize Matrx for an existing project (seeds system registry)")
 
     personal = subparsers.add_parser("personal")
     personal_subparsers = personal.add_subparsers(dest="personal_command")
@@ -119,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")
@@ -553,11 +571,20 @@ 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'))}")
     print("Auth:")
     print(
         "  matrx: "
@@ -971,5 +998,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())