mtrx-cli 0.1.0

package/src/matrx/cli/state.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from copy import deepcopy
+from pathlib import Path
+from urllib.parse import urlparse, urlunparse
+
+DEFAULT_MATRX_BASE_URL = "https://api.mtrx.so"
+DEFAULT_MATRX_APP_URL = "https://mtrx.so"
+LEGACY_MATRX_BASE_URLS = {
+    "https://api.matrx.dev": DEFAULT_MATRX_BASE_URL,
+}
+LEGACY_MATRX_APP_URLS = {
+    "https://app.matrx.dev",
+}
+PUBLIC_MATRX_APP_HOSTS_BY_API_HOST = {
+    "api.matrx.dev": "mtrx.so",
+    "api.mtrx.so": "mtrx.so",
+}
+CONFIG_ENV_VAR = "MTRX_CONFIG_DIR"
+CONFIG_FILENAME = "config.json"
+
+DEFAULT_STATE: dict = {
+    "version": 1,
+    "auth": {
+        "matrx": {
+            "key": None,
+            "base_url": DEFAULT_MATRX_BASE_URL,
+            "app_url": DEFAULT_MATRX_APP_URL,
+        },
+        "openai": {
+            "key": None,
+        },
+        "anthropic": {
+            "key": None,
+        },
+        "claude_code": {
+            "oauth_token": None,
+        },
+    },
+    "defaults": {
+        "codex": None,
+        "claude": None,
+    },
+    "workspaces": {
+        "bindings": {},
+    },
+    "setup": {
+        "tool_sync": {
+            "codex": {
+                "provider": None,
+                "fingerprint": None,
+                "consent_granted": False,
+                "scope": None,
+            },
+            "claude": {
+                "provider": None,
+                "fingerprint": None,
+                "consent_granted": False,
+                "scope": None,
+            },
+        },
+        "tool_config": {
+            "codex": {
+                "configured": False,
+                "verified": False,
+                "config_path": None,
+                "backup_path": None,
+                "original_backup_path": None,
+                "config_fingerprint": None,
+                "matrx_key_fingerprint": None,
+                "last_verified_at": None,
+                "previous_model_provider": None,
+                "previous_matrx_block": None,
+                "previous_values": {},
+            },
+            "claude": {
+                "configured": False,
+                "verified": False,
+                "config_path": None,
+                "backup_path": None,
+                "original_backup_path": None,
+                "config_fingerprint": None,
+                "matrx_key_fingerprint": None,
+                "last_verified_at": None,
+                "previous_model_provider": None,
+                "previous_matrx_block": None,
+                "previous_values": {},
+            },
+        },
+    },
+}
+
+
+def config_dir() -> Path:
+    override = os.environ.get(CONFIG_ENV_VAR)
+    if override:
+        return Path(override).expanduser()
+    appdata = os.environ.get("APPDATA")
+    if appdata:
+        return Path(appdata) / "mtrx"
+    return Path.home() / ".config" / "mtrx"
+
+
+def config_path() -> Path:
+    return config_dir() / CONFIG_FILENAME
+
+
+def load_state() -> dict:
+    path = config_path()
+    state = deepcopy(DEFAULT_STATE)
+    if not path.exists():
+        return state
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return state
+    _merge_dicts(state, raw if isinstance(raw, dict) else {})
+    _normalize_state(state)
+    return state
+
+
+def save_state(state: dict) -> Path:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+    return path
+
+
+def mask_secret(value: str | None) -> str:
+    if not value:
+        return "not set"
+    if len(value) <= 8:
+        return "*" * len(value)
+    return f"{value[:4]}...{value[-4:]}"
+
+
+def ensure_v1_url(base_url: str | None) -> str:
+    cleaned = _normalize_base_url(base_url).rstrip("/")
+    if cleaned.endswith("/v1"):
+        return cleaned
+    return f"{cleaned}/v1"
+
+
+def ensure_root_url(base_url: str | None) -> str:
+    cleaned = _normalize_base_url(base_url).rstrip("/")
+    if cleaned.endswith("/v1"):
+        return cleaned[:-3]
+    return cleaned
+
+
+def ensure_app_url(app_url: str | None, *, base_url: str | None = None) -> str:
+    explicit = (app_url or "").strip().rstrip("/")
+    if explicit:
+        normalized = _normalize_known_app_url(explicit, base_url=base_url)
+        if normalized:
+            return normalized
+        return explicit
+
+    parsed = urlparse(ensure_root_url(base_url))
+    scheme = parsed.scheme or "https"
+    host = parsed.hostname or ""
+
+    if host in {"127.0.0.1", "localhost"}:
+        return urlunparse((scheme, f"{host}:5173", "", "", "", ""))
+
+    if host in PUBLIC_MATRX_APP_HOSTS_BY_API_HOST:
+        host = PUBLIC_MATRX_APP_HOSTS_BY_API_HOST[host]
+    if host.startswith("api."):
+        host = host[4:]
+
+    if not host:
+        return DEFAULT_MATRX_APP_URL
+
+    if parsed.port and parsed.port not in {80, 443}:
+        netloc = f"{host}:{parsed.port}"
+    else:
+        netloc = host
+    return urlunparse((scheme, netloc, "", "", "", ""))
+
+
+def resolve_workspace_root(cwd: str | os.PathLike[str] | None = None) -> str:
+    root = Path(cwd or os.environ.get("PWD") or os.getcwd()).expanduser().resolve()
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(root), "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+            check=False,
+        )
+        if result.returncode == 0:
+            git_root = result.stdout.strip()
+            if git_root:
+                return str(Path(git_root).expanduser().resolve())
+    except (OSError, ValueError, subprocess.SubprocessError):
+        pass
+    return str(root)
+
+
+def get_workspace_binding(
+    state: dict,
+    *,
+    cwd: str | os.PathLike[str] | None = None,
+) -> dict | None:
+    root = resolve_workspace_root(cwd)
+    bindings = state.setdefault("workspaces", {}).setdefault("bindings", {})
+    binding = bindings.get(root)
+    if not isinstance(binding, dict):
+        return None
+    if not any(binding.get(field) for field in ("matrx_key", "project_id", "group_id")):
+        return None
+    return deepcopy(binding)
+
+
+def set_workspace_binding(
+    state: dict,
+    *,
+    cwd: str | os.PathLike[str] | None = None,
+    matrx_key: str | None = None,
+    project_id: str | None = None,
+    group_id: str | None = None,
+) -> bool:
+    root = resolve_workspace_root(cwd)
+    bindings = state.setdefault("workspaces", {}).setdefault("bindings", {})
+    existing = deepcopy(bindings.get(root) if isinstance(bindings.get(root), dict) else {})
+    updated = deepcopy(existing)
+
+    for field, raw_value in (
+        ("matrx_key", matrx_key),
+        ("project_id", project_id),
+        ("group_id", group_id),
+    ):
+        if raw_value is None:
+            continue
+        cleaned = raw_value.strip()
+        if cleaned:
+            updated[field] = cleaned
+        else:
+            updated.pop(field, None)
+
+    if not any(updated.get(field) for field in ("matrx_key", "project_id", "group_id")):
+        if root in bindings:
+            bindings.pop(root, None)
+            return True
+        return False
+
+    if updated == existing:
+        return False
+
+    bindings[root] = updated
+    return True
+
+
+def _merge_dicts(target: dict, source: dict) -> None:
+    for key, value in source.items():
+        if key in target and isinstance(target[key], dict) and isinstance(value, dict):
+            _merge_dicts(target[key], value)
+        else:
+            target[key] = value
+
+
+def _normalize_state(state: dict) -> None:
+    auth = state.setdefault("auth", {}).setdefault("matrx", {})
+    auth["base_url"] = _normalize_base_url(auth.get("base_url"))
+    auth["app_url"] = ensure_app_url(
+        auth.get("app_url"),
+        base_url=auth.get("base_url"),
+    )
+
+
+def _normalize_base_url(base_url: str | None) -> str:
+    cleaned = (base_url or DEFAULT_MATRX_BASE_URL).strip().rstrip("/")
+    return LEGACY_MATRX_BASE_URLS.get(cleaned, cleaned)
+
+
+def _normalize_known_app_url(app_url: str, *, base_url: str | None = None) -> str | None:
+    if app_url not in LEGACY_MATRX_APP_URLS:
+        return None
+
+    parsed = urlparse(ensure_root_url(base_url))
+    host = parsed.hostname or ""
+    if not host or host in PUBLIC_MATRX_APP_HOSTS_BY_API_HOST:
+        return DEFAULT_MATRX_APP_URL
+    return None