aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/config.py

@@ -0,0 +1,298 @@
+"""Daemon configuration — mirrors the Go daemon env/config surface for MVP."""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import socket
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_SERVER_URL = "http://localhost:8080"
+DEFAULT_POLL_INTERVAL = 30.0
+DEFAULT_HEARTBEAT_INTERVAL = 15.0
+DEFAULT_AGENT_TIMEOUT = 2 * 60 * 60.0
+DEFAULT_HEALTH_PORT = 19514  # align with Go daemon / `aicortex daemon status`
+DEFAULT_MAX_CONCURRENT = 4
+DEFAULT_GC_INTERVAL = 3600.0
+DEFAULT_GC_TTL = 86400.0
+DEFAULT_GC_ORPHAN_TTL = 259200.0
+DEFAULT_GC_ARTIFACT_TTL = 43200.0
+DEFAULT_CHAT_ACP_IDLE_TIMEOUT = 300.0
+DEFAULT_CHAT_ACP_MAX_CONNECTIONS = 50
+DEFAULT_AGENT_IDLE_WATCHDOG = 300.0  # 5m; 0 disables
+DEFAULT_CODEX_SEMANTIC_INACTIVITY = 600.0  # 10m; 0 disables
+CLI_VERSION = "0.1.0-python"
+
+# provider -> (env path override, default binary name, model env)
+# Keep in sync with server/internal/daemon/config.go probe list.
+AGENT_PROBES: list[tuple[str, str, str, str]] = [
+    ("claude", "AICORTEX_CLAUDE_PATH", "claude", "AICORTEX_CLAUDE_MODEL"),
+    ("codex", "AICORTEX_CODEX_PATH", "codex", "AICORTEX_CODEX_MODEL"),
+    ("opencode", "AICORTEX_OPENCODE_PATH", "opencode", "AICORTEX_OPENCODE_MODEL"),
+    ("openclaw", "AICORTEX_OPENCLAW_PATH", "openclaw", "AICORTEX_OPENCLAW_MODEL"),
+    ("hermes", "AICORTEX_HERMES_PATH", "hermes", "AICORTEX_HERMES_MODEL"),
+    ("gemini", "AICORTEX_GEMINI_PATH", "gemini", "AICORTEX_GEMINI_MODEL"),
+    ("pi", "AICORTEX_PI_PATH", "pi", "AICORTEX_PI_MODEL"),
+    ("cursor", "AICORTEX_CURSOR_PATH", "cursor-agent", "AICORTEX_CURSOR_MODEL"),
+    ("copilot", "AICORTEX_COPILOT_PATH", "copilot", "AICORTEX_COPILOT_MODEL"),
+    ("kimi", "AICORTEX_KIMI_PATH", "kimi", "AICORTEX_KIMI_MODEL"),
+    ("kiro", "AICORTEX_KIRO_PATH", "kiro-cli", "AICORTEX_KIRO_MODEL"),
+    ("dsh", "AICORTEX_DSH_PATH", "dsh", "AICORTEX_DSH_MODEL"),
+]
+
+
+@dataclass
+class AgentEntry:
+    path: str
+    model: str = ""
+
+
+@dataclass
+class CLIConfig:
+    server_url: str = ""
+    app_url: str = ""
+    workspace_id: str = ""
+    token: str = ""
+
+
+@dataclass
+class Config:
+    server_base_url: str
+    token: str
+    daemon_id: str
+    device_name: str
+    cli_version: str = CLI_VERSION
+    agents: dict[str, AgentEntry] = field(default_factory=dict)
+    workspaces_root: Path = field(default_factory=lambda: Path.home() / "aicortex_workspaces")
+    health_port: int = DEFAULT_HEALTH_PORT
+    poll_interval: float = DEFAULT_POLL_INTERVAL
+    heartbeat_interval: float = DEFAULT_HEARTBEAT_INTERVAL
+    agent_timeout: float = DEFAULT_AGENT_TIMEOUT
+    max_concurrent_tasks: int = DEFAULT_MAX_CONCURRENT
+    profile: str = ""
+    state_dir: Path = field(default_factory=lambda: Path.home() / ".aicortex")
+    gc_enabled: bool = True
+    gc_interval: float = DEFAULT_GC_INTERVAL
+    gc_ttl: float = DEFAULT_GC_TTL
+    gc_orphan_ttl: float = DEFAULT_GC_ORPHAN_TTL
+    gc_artifact_ttl: float = DEFAULT_GC_ARTIFACT_TTL
+    cursor_acp_enabled: bool = True
+    kiro_acp_enabled: bool = True
+    chat_acp_idle_timeout: float = DEFAULT_CHAT_ACP_IDLE_TIMEOUT
+    chat_acp_max_connections: int = DEFAULT_CHAT_ACP_MAX_CONNECTIONS
+    agent_idle_watchdog: float = DEFAULT_AGENT_IDLE_WATCHDOG
+    codex_semantic_inactivity: float = DEFAULT_CODEX_SEMANTIC_INACTIVITY
+
+
+def profile_dir(profile: str = "") -> Path:
+    home = Path.home() / ".aicortex"
+    if profile:
+        return home / "profiles" / profile
+    return home
+
+
+def cli_config_path(profile: str = "") -> Path:
+    return profile_dir(profile) / "config.json"
+
+
+def load_cli_config(profile: str = "") -> CLIConfig:
+    path = cli_config_path(profile)
+    if not path.is_file():
+        return CLIConfig()
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return CLIConfig(
+        server_url=str(data.get("server_url") or ""),
+        app_url=str(data.get("app_url") or ""),
+        workspace_id=str(data.get("workspace_id") or ""),
+        token=str(data.get("token") or ""),
+    )
+
+
+def normalize_http_base(url: str) -> str:
+    u = (url or "").strip().rstrip("/")
+    if u.startswith("ws://"):
+        u = "http://" + u[len("ws://") :]
+    elif u.startswith("wss://"):
+        u = "https://" + u[len("wss://") :]
+    # Strip trailing /ws used by Go default
+    if u.endswith("/ws"):
+        u = u[: -len("/ws")]
+    return u.rstrip("/")
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    return float(raw)
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    return int(raw)
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None or not str(raw).strip():
+        return default
+    return str(raw).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def discover_agents() -> dict[str, AgentEntry]:
+    agents: dict[str, AgentEntry] = {}
+    for provider, path_env, default_bin, model_env in AGENT_PROBES:
+        override = os.environ.get(path_env, "").strip()
+        path = override or shutil.which(default_bin) or ""
+        if not path:
+            continue
+        if override and not Path(override).exists() and not shutil.which(override):
+            continue
+        resolved = shutil.which(path) or path
+        agents[provider] = AgentEntry(
+            path=resolved,
+            model=os.environ.get(model_env, "").strip(),
+        )
+    return agents
+
+
+def default_daemon_id() -> str:
+    host = socket.gethostname() or "local"
+    # Stable-ish id per machine for python daemon
+    seed = f"python-daemon:{host}:{platform.node()}"
+    return "py-" + uuid.uuid5(uuid.NAMESPACE_DNS, seed).hex[:12]
+
+
+def health_port_for_profile(profile: str = "") -> int:
+    """Match Go healthPortForProfile so `aicortex daemon status` finds us."""
+    if not profile:
+        return DEFAULT_HEALTH_PORT
+    h = sum(ord(c) for c in profile)
+    return DEFAULT_HEALTH_PORT + 1 + (h % 1000)
+
+
+def load_config(profile: str = "", *, require_agents: bool = True) -> Config:
+    cli = load_cli_config(profile)
+    server = normalize_http_base(
+        os.environ.get("AICORTEX_SERVER_URL")
+        or cli.server_url
+        or DEFAULT_SERVER_URL
+    )
+    token = os.environ.get("AICORTEX_TOKEN") or cli.token
+    if not token:
+        raise SystemExit(
+            "No auth token. Run `aicortex setup`/`login` first, or set AICORTEX_TOKEN."
+        )
+
+    agents = discover_agents()
+    if require_agents and not agents:
+        raise SystemExit(
+            "No agent CLI found. Install claude/codex/... and ensure it is on PATH, "
+            "or set AICORTEX_CLAUDE_PATH / AICORTEX_CODEX_PATH."
+        )
+
+    host = socket.gethostname() or "local-machine"
+    state = profile_dir(profile)
+    workspaces = Path(
+        os.environ.get("AICORTEX_WORKSPACES_ROOT")
+        or (Path.home() / "aicortex_workspaces")
+    )
+
+    return Config(
+        server_base_url=server,
+        token=token,
+        daemon_id=os.environ.get("aicortex_ID") or default_daemon_id(),
+        device_name=os.environ.get("aicortex_DEVICE_NAME") or host,
+        cli_version=os.environ.get("AICORTEX_CLI_VERSION") or CLI_VERSION,
+        agents=agents,
+        workspaces_root=workspaces,
+        health_port=_env_int(
+            "aicortex_HEALTH_PORT", health_port_for_profile(profile)
+        ),
+        poll_interval=_env_float("aicortex_POLL_INTERVAL", DEFAULT_POLL_INTERVAL),
+        heartbeat_interval=_env_float(
+            "aicortex_HEARTBEAT_INTERVAL", DEFAULT_HEARTBEAT_INTERVAL
+        ),
+        agent_timeout=_env_float("AICORTEX_AGENT_TIMEOUT", DEFAULT_AGENT_TIMEOUT),
+        max_concurrent_tasks=_env_int(
+            "aicortex_MAX_CONCURRENT_TASKS", DEFAULT_MAX_CONCURRENT
+        ),
+        profile=profile,
+        state_dir=state,
+        gc_enabled=_env_bool("AICORTEX_GC_ENABLED", True),
+        gc_interval=_env_float("AICORTEX_GC_INTERVAL", DEFAULT_GC_INTERVAL),
+        gc_ttl=_env_float("AICORTEX_GC_TTL", DEFAULT_GC_TTL),
+        gc_orphan_ttl=_env_float("AICORTEX_GC_ORPHAN_TTL", DEFAULT_GC_ORPHAN_TTL),
+        gc_artifact_ttl=_env_float("AICORTEX_GC_ARTIFACT_TTL", DEFAULT_GC_ARTIFACT_TTL),
+        cursor_acp_enabled=_env_bool("AICORTEX_CURSOR_ACP_ENABLED", True),
+        kiro_acp_enabled=_env_bool("AICORTEX_KIRO_ACP_ENABLED", True),
+        chat_acp_idle_timeout=_env_float(
+            "AICORTEX_CHAT_ACP_IDLE_TIMEOUT", DEFAULT_CHAT_ACP_IDLE_TIMEOUT
+        ),
+        chat_acp_max_connections=_env_int(
+            "AICORTEX_CHAT_ACP_MAX_CONNECTIONS", DEFAULT_CHAT_ACP_MAX_CONNECTIONS
+        ),
+        agent_idle_watchdog=_env_float(
+            "AICORTEX_AGENT_IDLE_WATCHDOG", DEFAULT_AGENT_IDLE_WATCHDOG
+        ),
+        codex_semantic_inactivity=_env_float(
+            "AICORTEX_CODEX_SEMANTIC_INACTIVITY_TIMEOUT",
+            DEFAULT_CODEX_SEMANTIC_INACTIVITY,
+        ),
+    )
+
+
+def detect_local_timezone() -> str:
+    try:
+        return str(__import__("datetime").datetime.now().astimezone().tzinfo)
+    except Exception:
+        return "UTC"
+
+
+def detect_agent_version(executable: str) -> str:
+    """Best-effort `cli --version` parse; falls back to 'unknown'."""
+    import re
+    import subprocess
+
+    for args in ([executable, "--version"], [executable, "version"], [executable, "-V"]):
+        try:
+            proc = subprocess.run(
+                args,
+                capture_output=True,
+                text=True,
+                timeout=15,
+                check=False,
+            )
+            out = (proc.stdout or "") + "\n" + (proc.stderr or "")
+            m = re.search(r"(\d+\.\d+(?:\.\d+)?)", out)
+            if m:
+                return m.group(1)
+        except Exception:
+            continue
+    return "unknown"
+
+
+def as_register_runtimes(cfg: Config) -> list[dict[str, Any]]:
+    runtimes: list[dict[str, Any]] = []
+    for name, entry in cfg.agents.items():
+        version = detect_agent_version(entry.path)
+        display = name[:1].upper() + name[1:]
+        if cfg.device_name:
+            display = f"{display} ({cfg.device_name})"
+        runtimes.append(
+            {
+                "name": display,
+                "type": name,
+                "version": version,
+                "status": "online",
+            }
+        )
+    return runtimes