aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/client.py

@@ -0,0 +1,438 @@
+"""HTTP client for AICortex daemon API endpoints."""
+
+from __future__ import annotations
+
+import json
+import ssl
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any
+
+from .platform_info import host_os
+
+MAX_ATTACHMENT_BYTES = 100 << 20
+
+
+class APIError(Exception):
+    def __init__(self, method: str, path: str, status: int, body: str):
+        self.method = method
+        self.path = path
+        self.status = status
+        self.body = body
+        super().__init__(f"{method} {path} returned {status}: {body[:500]}")
+
+
+def is_not_found(err: Exception, needle: str) -> bool:
+    return (
+        isinstance(err, APIError)
+        and err.status == 404
+        and needle.lower() in err.body.lower()
+    )
+
+
+@dataclass
+class Task:
+    raw: dict[str, Any]
+
+    def _s(self, key: str) -> str:
+        return str(self.raw.get(key) or "")
+
+    @property
+    def id(self) -> str:
+        return self._s("id")
+
+    @property
+    def runtime_id(self) -> str:
+        return self._s("runtime_id")
+
+    @property
+    def issue_id(self) -> str:
+        return self._s("issue_id")
+
+    @property
+    def workspace_id(self) -> str:
+        return self._s("workspace_id")
+
+    @property
+    def chat_session_id(self) -> str:
+        return self._s("chat_session_id")
+
+    @property
+    def chat_message(self) -> str:
+        return self._s("chat_message")
+
+    @property
+    def autopilot_run_id(self) -> str:
+        return self._s("autopilot_run_id")
+
+    @property
+    def autopilot_id(self) -> str:
+        return self._s("autopilot_id")
+
+    @property
+    def autopilot_description(self) -> str:
+        return self._s("autopilot_description")
+
+    @property
+    def autopilot_title(self) -> str:
+        return self._s("autopilot_title")
+
+    @property
+    def autopilot_source(self) -> str:
+        return self._s("autopilot_source")
+
+    @property
+    def autopilot_trigger_payload(self) -> str:
+        p = self.raw.get("autopilot_trigger_payload")
+        if p is None:
+            return ""
+        if isinstance(p, (dict, list)):
+            return json.dumps(p, ensure_ascii=False)
+        return str(p)
+
+    @property
+    def quick_create_prompt(self) -> str:
+        return self._s("quick_create_prompt")
+
+    @property
+    def trigger_comment_id(self) -> str:
+        return self._s("trigger_comment_id")
+
+    @property
+    def trigger_comment_content(self) -> str:
+        return self._s("trigger_comment_content")
+
+    @property
+    def trigger_author_type(self) -> str:
+        return self._s("trigger_author_type")
+
+    @property
+    def trigger_author_name(self) -> str:
+        return self._s("trigger_author_name")
+
+    @property
+    def project_id(self) -> str:
+        return self._s("project_id")
+
+    @property
+    def project_title(self) -> str:
+        return self._s("project_title")
+
+    @property
+    def project_prompt(self) -> str:
+        return self._s("project_prompt")
+
+    @property
+    def project_pinned_workdir(self) -> bool:
+        return bool(self.raw.get("project_pinned_workdir"))
+
+    @property
+    def project_resources(self) -> list[dict[str, Any]]:
+        r = self.raw.get("project_resources")
+        return [x for x in r if isinstance(x, dict)] if isinstance(r, list) else []
+
+    @property
+    def prior_session_id(self) -> str:
+        return self._s("prior_session_id")
+
+    @property
+    def prior_work_dir(self) -> str:
+        return self._s("prior_work_dir")
+
+    @property
+    def design_mode(self) -> str:
+        return self._s("design_mode")
+
+    @property
+    def design_system_content(self) -> str:
+        return self._s("design_system_content")
+
+    @property
+    def design_system_name(self) -> str:
+        return self._s("design_system_name")
+
+    @property
+    def design_example_hint(self) -> str:
+        return self._s("design_example_hint")
+
+    @property
+    def design_example_id(self) -> str:
+        return self._s("design_example_id")
+
+    @property
+    def design_example_bundles(self) -> list[dict[str, Any]]:
+        b = self.raw.get("design_example_bundles")
+        return [x for x in b if isinstance(x, dict)] if isinstance(b, list) else []
+
+    @property
+    def handoff_bundle_url(self) -> str:
+        return self._s("handoff_bundle_url")
+
+    @property
+    def artifact_entry(self) -> str:
+        return self._s("artifact_entry")
+
+    @property
+    def session_kind(self) -> str:
+        return self._s("session_kind")
+
+    @property
+    def squad_id(self) -> str:
+        return self._s("squad_id")
+
+    @property
+    def squad_name(self) -> str:
+        return self._s("squad_name")
+
+    @property
+    def agent(self) -> dict[str, Any] | None:
+        a = self.raw.get("agent")
+        return a if isinstance(a, dict) else None
+
+    @property
+    def repos(self) -> list[dict[str, Any]]:
+        repos = self.raw.get("repos")
+        if not isinstance(repos, list):
+            return []
+        return [r for r in repos if isinstance(r, dict)]
+
+    @property
+    def chat_history(self) -> list[dict[str, Any]]:
+        h = self.raw.get("chat_history")
+        return [x for x in h if isinstance(x, dict)] if isinstance(h, list) else []
+
+    @property
+    def chat_message_attachments(self) -> list[dict[str, Any]]:
+        a = self.raw.get("chat_message_attachments")
+        if not isinstance(a, list):
+            a = self.raw.get("attachments")
+        return [x for x in a if isinstance(x, dict)] if isinstance(a, list) else []
+
+    @property
+    def attachments(self) -> list[dict[str, Any]]:
+        return self.chat_message_attachments
+
+    # Daemon-local: filled after materialize
+    design_incoming_rel_paths: list[str] | None = None
+
+
+class DaemonClient:
+    def __init__(
+        self,
+        base_url: str,
+        token: str,
+        *,
+        version: str = "",
+        timeout: float = 30.0,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.version = version
+        self.timeout = timeout
+        self._ctx = ssl.create_default_context()
+
+    def _headers(self, *, json_body: bool = False) -> dict[str, str]:
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.token}",
+            "X-Client-Platform": "daemon",
+            "X-Client-OS": host_os(),
+        }
+        if self.version:
+            headers["X-Client-Version"] = self.version
+        if json_body:
+            headers["Content-Type"] = "application/json"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Any | None = None,
+    ) -> Any:
+        url = self.base_url + path
+        data = None
+        headers = self._headers(json_body=body is not None)
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout, context=self._ctx) as resp:
+                raw = resp.read()
+                if not raw:
+                    return None
+                return json.loads(raw.decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            err_body = e.read().decode("utf-8", errors="replace")
+            raise APIError(method, path, e.code, err_body) from e
+
+    def get(self, path: str) -> Any:
+        return self._request("GET", path)
+
+    def post(self, path: str, body: Any | None = None) -> Any:
+        return self._request("POST", path, body if body is not None else {})
+
+    def list_workspaces(self) -> list[dict[str, Any]]:
+        data = self.get("/api/workspaces")
+        return data if isinstance(data, list) else []
+
+    def register(self, payload: dict[str, Any]) -> dict[str, Any]:
+        data = self.post("/api/daemon/register", payload)
+        return data if isinstance(data, dict) else {}
+
+    def deregister(self, runtime_ids: list[str]) -> None:
+        self.post("/api/daemon/deregister", {"runtime_ids": runtime_ids})
+
+    def recover_orphans(self, runtime_id: str) -> None:
+        self.post(f"/api/daemon/runtimes/{runtime_id}/recover-orphans", {})
+
+    def heartbeat(self, runtime_id: str) -> dict[str, Any]:
+        data = self.post("/api/daemon/heartbeat", {"runtime_id": runtime_id})
+        return data if isinstance(data, dict) else {}
+
+    def claim_task(self, runtime_id: str) -> Task | None:
+        data = self.post(f"/api/daemon/runtimes/{runtime_id}/tasks/claim", {})
+        if not isinstance(data, dict):
+            return None
+        task = data.get("task")
+        if not task:
+            return None
+        return Task(task)
+
+    def start_task(self, task_id: str) -> None:
+        self.post(f"/api/daemon/tasks/{task_id}/start", {})
+
+    def report_progress(self, task_id: str, summary: str, step: int, total: int) -> None:
+        self.post(
+            f"/api/daemon/tasks/{task_id}/progress",
+            {"summary": summary, "step": step, "total": total},
+        )
+
+    def complete_task(
+        self,
+        task_id: str,
+        output: str,
+        *,
+        work_dir: str = "",
+        session_id: str = "",
+        branch_name: str = "",
+    ) -> None:
+        body: dict[str, Any] = {"output": output}
+        if work_dir:
+            body["work_dir"] = work_dir
+        if session_id:
+            body["session_id"] = session_id
+        if branch_name:
+            body["branch_name"] = branch_name
+        self.post(f"/api/daemon/tasks/{task_id}/complete", body)
+
+    def fail_task(
+        self,
+        task_id: str,
+        error: str,
+        *,
+        work_dir: str = "",
+        session_id: str = "",
+        failure_reason: str = "agent_error",
+    ) -> None:
+        body: dict[str, Any] = {"error": error, "failure_reason": failure_reason}
+        if work_dir:
+            body["work_dir"] = work_dir
+        if session_id:
+            body["session_id"] = session_id
+        self.post(f"/api/daemon/tasks/{task_id}/fail", body)
+
+    def pin_task_session(
+        self,
+        task_id: str,
+        *,
+        session_id: str = "",
+        work_dir: str = "",
+    ) -> None:
+        if not session_id and not work_dir:
+            return
+        body: dict[str, Any] = {}
+        if session_id:
+            body["session_id"] = session_id
+        if work_dir:
+            body["work_dir"] = work_dir
+        self.post(f"/api/daemon/tasks/{task_id}/session", body)
+
+    def get_task_status(self, task_id: str) -> str:
+        data = self.get(f"/api/daemon/tasks/{task_id}/status")
+        if isinstance(data, dict):
+            return str(data.get("status") or "")
+        return ""
+
+    def report_task_messages(self, task_id: str, messages: list[dict[str, Any]]) -> None:
+        if not messages:
+            return
+        self.post(f"/api/daemon/tasks/{task_id}/messages", {"messages": messages})
+
+    def report_task_usage(self, task_id: str, usage: list[dict[str, Any]]) -> None:
+        if not usage:
+            return
+        self.post(f"/api/daemon/tasks/{task_id}/usage", {"usage": usage})
+
+    def report_task_artifacts(self, task_id: str, artifacts: list[dict[str, str]]) -> None:
+        if not artifacts:
+            return
+        self.post(f"/api/daemon/tasks/{task_id}/artifacts", {"artifacts": artifacts})
+
+    def report_model_list_result(
+        self, runtime_id: str, request_id: str, result: dict[str, Any]
+    ) -> None:
+        self.post(f"/api/daemon/runtimes/{runtime_id}/models/{request_id}/result", result)
+
+    def report_local_skill_list_result(
+        self, runtime_id: str, request_id: str, result: dict[str, Any]
+    ) -> None:
+        self.post(
+            f"/api/daemon/runtimes/{runtime_id}/local-skills/{request_id}/result",
+            result,
+        )
+
+    def report_local_skill_import_result(
+        self, runtime_id: str, request_id: str, result: dict[str, Any]
+    ) -> None:
+        self.post(
+            f"/api/daemon/runtimes/{runtime_id}/local-skills/import/{request_id}/result",
+            result,
+        )
+
+    def get_issue_gc_check(self, issue_id: str) -> dict[str, Any]:
+        data = self.get(f"/api/daemon/issues/{issue_id}/gc-check")
+        return data if isinstance(data, dict) else {}
+
+    def get_chat_session_gc_check(self, session_id: str) -> dict[str, Any]:
+        data = self.get(f"/api/daemon/chat-sessions/{session_id}/gc-check")
+        return data if isinstance(data, dict) else {}
+
+    def get_autopilot_run_gc_check(self, run_id: str) -> dict[str, Any]:
+        data = self.get(f"/api/daemon/autopilot-runs/{run_id}/gc-check")
+        return data if isinstance(data, dict) else {}
+
+    def get_task_gc_check(self, task_id: str) -> dict[str, Any]:
+        data = self.get(f"/api/daemon/tasks/{task_id}/gc-check")
+        return data if isinstance(data, dict) else {}
+
+    def get_workspace_repos(self, workspace_id: str) -> dict[str, Any]:
+        data = self.get(f"/api/daemon/workspaces/{workspace_id}/repos")
+        return data if isinstance(data, dict) else {}
+
+    def fetch_attachment_bytes(self, attachment_id: str) -> tuple[bytes, str]:
+        path = f"/api/daemon/attachments/{attachment_id}/bytes"
+        url = self.base_url + path
+        req = urllib.request.Request(url, headers=self._headers(), method="GET")
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout, context=self._ctx) as resp:
+                body = resp.read(MAX_ATTACHMENT_BYTES + 1)
+                if len(body) > MAX_ATTACHMENT_BYTES:
+                    raise APIError("GET", path, 413, "attachment exceeds size limit")
+                filename = resp.headers.get("X-Attachment-Filename") or ""
+                return body, filename
+        except urllib.error.HTTPError as e:
+            err_body = e.read().decode("utf-8", errors="replace")
+            raise APIError("GET", path, e.code, err_body) from e

aicortexpy/codex_config.py

@@ -0,0 +1,98 @@
+"""Codex per-task CODEX_HOME config helpers (skill strip + multi-agent disable)."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from pathlib import Path
+
+log = logging.getLogger("aicortexpy.codex_config")
+
+MULTI_AGENT_BEGIN = "# BEGIN aicortex-managed multi-agent (do not edit; regenerated by daemon)"
+MULTI_AGENT_END = "# END aicortex-managed multi-agent"
+_MULTI_AGENT_BLOCK_RE = re.compile(
+    rf"(?ms)^{re.escape(MULTI_AGENT_BEGIN)}.*?^{re.escape(MULTI_AGENT_END)}\n*"
+)
+
+
+def strip_skills_config_entries(content: str) -> str:
+    """Remove [[skills.config]] blocks that break Codex CLI (missing path)."""
+    if "[[skills.config]]" not in content:
+        return content
+    out: list[str] = []
+    in_skills = False
+    for line in content.splitlines(keepends=True):
+        trimmed = line.strip()
+        if trimmed.startswith("["):
+            if trimmed == "[[skills.config]]":
+                in_skills = True
+                continue
+            in_skills = False
+            out.append(line)
+            continue
+        if in_skills:
+            continue
+        out.append(line)
+    stripped = "".join(out).rstrip("\n") + "\n"
+    return "" if not stripped.strip() else stripped
+
+
+def sanitize_copied_codex_config(config_path: Path) -> None:
+    if not config_path.is_file():
+        return
+    try:
+        text = config_path.read_text(encoding="utf-8")
+    except OSError as e:
+        log.warning("read codex config failed: %s", e)
+        return
+    stripped = strip_skills_config_entries(text)
+    if stripped == text:
+        return
+    try:
+        config_path.write_text(stripped, encoding="utf-8")
+        log.info("stripped [[skills.config]] from %s", config_path)
+    except OSError as e:
+        log.warning("write sanitized codex config failed: %s", e)
+
+
+def codex_multi_agent_enabled() -> bool:
+    raw = (os.environ.get("AICORTEX_CODEX_MULTI_AGENT") or "").strip().lower()
+    return raw in ("1", "true", "yes", "on")
+
+
+def ensure_codex_multi_agent_config(config_path: Path) -> None:
+    """Disable Codex native multi_agent unless AICORTEX_CODEX_MULTI_AGENT is set."""
+    if codex_multi_agent_enabled():
+        return
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    existing = ""
+    if config_path.is_file():
+        try:
+            existing = config_path.read_text(encoding="utf-8")
+        except OSError:
+            existing = ""
+    existing = _MULTI_AGENT_BLOCK_RE.sub("", existing)
+    in_features = bool(re.search(r"(?m)^\s*\[\s*features\s*\]\s*(?:#.*)?$", existing))
+    if in_features:
+        body = "multi_agent = false\n"
+    else:
+        body = "features.multi_agent = false\n"
+    block = f"{MULTI_AGENT_BEGIN}\n{body}{MULTI_AGENT_END}\n"
+    # Prefer injecting inside [features] when present.
+    if in_features:
+        lines = existing.splitlines(keepends=True)
+        out: list[str] = []
+        injected = False
+        for i, line in enumerate(lines):
+            out.append(line)
+            if not injected and re.match(r"^\s*\[\s*features\s*\]\s*(?:#.*)?$", line.strip()):
+                out.append(block)
+                injected = True
+        text = "".join(out) if injected else block + existing
+    else:
+        text = block + (existing if existing.endswith("\n") or not existing else existing + "\n")
+    try:
+        config_path.write_text(text, encoding="utf-8")
+    except OSError as e:
+        log.warning("write multi-agent config failed: %s", e)