aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/acp_errors.py

@@ -0,0 +1,107 @@
+"""ACP stderr provider-error sniffing + completed→failed promotion.
+
+Port of hermes.go acpProviderErrorSniffer / promoteACPResultOnProviderError
+(aicortex#1952: session/prompt often ends with end_turn even on HTTP 4xx/429).
+"""
+
+from __future__ import annotations
+
+import re
+import threading
+
+_ACP_ERROR_HEADER_RE = re.compile(
+    r"(?:⚠️|❌|\[ERROR\]).*(?:BadRequestError|AuthenticationError|RateLimitError|HTTP [0-9]{3}|Non-retryable|API call failed)"
+)
+_ACP_ERROR_DETAIL_RE = re.compile(r"(?:Error:|detail:|Details:)\s*(.+)")
+_ACP_TERMINAL_ERROR_RE = re.compile(
+    r"(?:❌|\[ERROR\]|after \d+ retr|Non-retryable|BadRequestError|AuthenticationError)"
+)
+_ACP_AGENT_OUTPUT_TERMINAL_RE = re.compile(r"API call failed after \d+ retr(?:y|ies)")
+_ACP_MAX_ERROR_LINES = 8
+
+
+class ACPProviderErrorSniffer:
+    def __init__(self, provider: str) -> None:
+        self.provider = provider
+        self._mu = threading.Lock()
+        self._remains = b""
+        self._lines: list[str] = []
+        self._seen: set[str] = set()
+        self._terminal = False
+
+    def write(self, data: bytes) -> int:
+        with self._mu:
+            buf = self._remains + data
+            nl = buf.rfind(b"\n")
+            if nl < 0:
+                self._remains = buf
+                return len(data)
+            complete = buf[:nl].decode("utf-8", errors="replace")
+            self._remains = buf[nl + 1 :]
+            for line in complete.split("\n"):
+                line = line.strip()
+                if not line:
+                    continue
+                if not (
+                    _ACP_ERROR_HEADER_RE.search(line) or _ACP_ERROR_DETAIL_RE.search(line)
+                ):
+                    continue
+                if _ACP_TERMINAL_ERROR_RE.search(line):
+                    self._terminal = True
+                if line in self._seen:
+                    continue
+                self._seen.add(line)
+                self._lines.append(line)
+                if len(self._lines) > _ACP_MAX_ERROR_LINES:
+                    self._lines = self._lines[-_ACP_MAX_ERROR_LINES:]
+        return len(data)
+
+    def feed_text(self, text: str) -> None:
+        if text and not text.endswith("\n"):
+            text = text + "\n"
+        self.write(text.encode("utf-8", errors="replace"))
+
+    def message(self) -> str:
+        with self._mu:
+            return self._message_locked()
+
+    def terminal_message(self) -> str:
+        with self._mu:
+            if not self._terminal:
+                return ""
+            return self._message_locked()
+
+    def _message_locked(self) -> str:
+        prefix = f"{self.provider} provider error: "
+        for line in self._lines:
+            m = _ACP_ERROR_DETAIL_RE.search(line)
+            if m:
+                detail = m.group(1).strip()
+                if detail:
+                    return prefix + detail
+        for line in self._lines:
+            if _ACP_ERROR_HEADER_RE.search(line):
+                return prefix + line
+        return ""
+
+
+def promote_acp_result_on_provider_error(
+    final_status: str,
+    final_error: str,
+    final_output: str,
+    sniffer: ACPProviderErrorSniffer | None,
+) -> tuple[str, str]:
+    if final_status != "completed" or sniffer is None:
+        return final_status, final_error
+    msg = sniffer.terminal_message()
+    if msg:
+        return "failed", msg
+    m = _ACP_AGENT_OUTPUT_TERMINAL_RE.search(final_output or "")
+    if m:
+        msg = sniffer.message() or f"{sniffer.provider} provider error: {m.group(0)}"
+        return "failed", msg
+    if not (final_output or "").strip():
+        msg = sniffer.message()
+        if msg:
+            return "failed", msg
+    return final_status, final_error

aicortexpy/agent_env.py

@@ -0,0 +1,88 @@
+"""Inject daemon identity env into spawned agent processes (mirrors Go runTask agentEnv)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+from .client import Task
+from .config import Config
+
+
+_BLOCKED_CUSTOM_ENV = frozenset(
+    {
+        "HOME",
+        "PATH",
+        "USER",
+        "SHELL",
+        "TERM",
+        "CODEX_HOME",
+        "OPENCLAW_CONFIG_PATH",
+        "OPENCLAW_INCLUDE_ROOTS",
+    }
+)
+
+
+def is_blocked_env_key(key: str) -> bool:
+    upper = key.upper()
+    if upper.startswith("AICORTEX_"):
+        return True
+    return upper in _BLOCKED_CUSTOM_ENV
+
+
+def _aicortex_bin_dir() -> str | None:
+    which = shutil.which("aicortexpy")
+    if which:
+        return str(Path(which).resolve().parent)
+    return None
+
+
+def build_agent_environ(
+    base: dict[str, str],
+    *,
+    cfg: Config,
+    task: Task,
+    task_slot: int = 0,
+    extra: dict[str, str] | None = None,
+) -> dict[str, str]:
+    """Merge OS env with daemon credentials, PATH prepend, and safe custom_env."""
+    environ = dict(base)
+    agent = task.agent or {}
+    agent_name = str(agent.get("name") or "agent")
+    agent_id = str(agent.get("id") or task.raw.get("agent_id") or "")
+
+    environ["AICORTEX_TOKEN"] = cfg.token
+    environ["AICORTEX_SERVER_URL"] = cfg.server_base_url
+    environ["aicortex_PORT"] = str(cfg.health_port)
+    environ["AICORTEX_WORKSPACE_ID"] = task.workspace_id or ""
+    environ["AICORTEX_AGENT_NAME"] = agent_name
+    environ["AICORTEX_AGENT_ID"] = agent_id
+    environ["AICORTEX_TASK_ID"] = task.id
+    environ["AICORTEX_TASK_SLOT"] = str(task_slot)
+
+    if task.autopilot_run_id:
+        environ["AICORTEX_AUTOPILOT_RUN_ID"] = task.autopilot_run_id
+    if task.autopilot_id:
+        environ["AICORTEX_AUTOPILOT_ID"] = task.autopilot_id
+    if task.quick_create_prompt:
+        environ["AICORTEX_QUICK_CREATE_TASK_ID"] = task.id
+
+    bin_dir = _aicortex_bin_dir()
+    if bin_dir:
+        prev = environ.get("PATH") or os.environ.get("PATH") or ""
+        environ["PATH"] = bin_dir + os.pathsep + prev
+
+    if extra:
+        environ.update({str(k): str(v) for k, v in extra.items()})
+
+    custom_env = agent.get("custom_env")
+    if isinstance(custom_env, dict):
+        for k, v in custom_env.items():
+            key = str(k)
+            if is_blocked_env_key(key):
+                continue
+            environ[key] = str(v)
+
+    return environ

aicortexpy/artifact_ws.py

@@ -0,0 +1,233 @@
+"""Artifact browse + chunked upload over wakeup WS (Go artifact/*)."""
+
+from __future__ import annotations
+
+import base64
+import logging
+import mimetypes
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+log = logging.getLogger("aicortexpy.artifact_ws")
+
+MAX_READ = 8 * 1024 * 1024
+UPLOAD_TTL = 300.0
+
+SendFn = Callable[[str, dict[str, Any]], None]
+
+
+def _resolve_under_root(root: str, rel: str) -> Path:
+    root_path = Path(root).resolve()
+    rel = (rel or "").replace("\\", "/").lstrip("/")
+    if ".." in rel.split("/"):
+        raise ValueError("path escapes root")
+    target = (root_path / rel).resolve() if rel else root_path
+    if not str(target).startswith(str(root_path)):
+        raise ValueError("path escapes root")
+    return target
+
+
+class ArtifactBrowser:
+    def __init__(self, send: SendFn | None = None):
+        self._send = send
+        self._mu = threading.Lock()
+        self._uploads: dict[str, dict[str, Any]] = {}
+
+    def set_send(self, send: SendFn) -> None:
+        self._send = send
+
+    def handle_request(self, payload: dict[str, Any]) -> None:
+        threading.Thread(
+            target=self._handle, args=(payload,), name="artifact-req", daemon=True
+        ).start()
+
+    def _reply(self, resp: dict[str, Any]) -> None:
+        if self._send:
+            self._send("artifact:response", resp)
+
+    def _handle(self, payload: dict[str, Any]) -> None:
+        req_id = str(payload.get("request_id") or payload.get("requestId") or "")
+        op = str(payload.get("op") or "").lower().strip()
+        resp: dict[str, Any] = {"request_id": req_id}
+        try:
+            if op in ("write_start", "write_chunk", "write_finish"):
+                if op == "write_start":
+                    self._write_start(payload)
+                    return
+                if op == "write_chunk":
+                    self._write_chunk(payload)
+                    return
+                resp = self._write_finish(payload)
+                self._reply(resp)
+                return
+
+            root = str(payload.get("root_path") or payload.get("rootPath") or "")
+            rel = str(payload.get("rel_path") or payload.get("relPath") or "")
+            if not root:
+                raise ValueError("root path required")
+            abs_path = _resolve_under_root(root, rel)
+
+            if op == "list":
+                resp["entries"] = self._list_dir(abs_path, rel)
+            elif op == "read":
+                body, ctype = self._read_file(abs_path)
+                resp["content_type"] = ctype
+                if body:
+                    resp["body"] = base64.b64encode(body).decode("ascii")
+            elif op == "write":
+                raw = b""
+                if payload.get("body"):
+                    raw = base64.b64decode(str(payload["body"]))
+                abs_path.parent.mkdir(parents=True, exist_ok=True)
+                abs_path.write_bytes(raw)
+            elif op == "delete":
+                if abs_path.is_dir():
+                    import shutil
+
+                    shutil.rmtree(abs_path)
+                elif abs_path.exists():
+                    abs_path.unlink()
+            elif op == "rename":
+                new_rel = str(payload.get("new_rel_path") or payload.get("newRelPath") or "")
+                new_abs = _resolve_under_root(root, new_rel)
+                new_abs.parent.mkdir(parents=True, exist_ok=True)
+                abs_path.rename(new_abs)
+            else:
+                raise ValueError(f"unknown artifact op {op!r}")
+        except Exception as e:
+            resp["error"] = str(e)
+        self._reply(resp)
+
+    def _list_dir(self, abs_path: Path, rel: str) -> list[dict[str, Any]]:
+        if not abs_path.is_dir():
+            raise ValueError("not a directory")
+        entries: list[dict[str, Any]] = []
+        for child in sorted(abs_path.iterdir(), key=lambda p: p.name.lower()):
+            try:
+                st = child.stat()
+            except OSError:
+                continue
+            entries.append(
+                {
+                    "name": child.name,
+                    "rel_path": f"{rel.rstrip('/')}/{child.name}".lstrip("/") if rel else child.name,
+                    "is_dir": child.is_dir(),
+                    "size": st.st_size if child.is_file() else 0,
+                    "mtime": int(st.st_mtime),
+                }
+            )
+        return entries
+
+    def _read_file(self, abs_path: Path) -> tuple[bytes, str]:
+        if not abs_path.is_file():
+            raise ValueError("not a file")
+        data = abs_path.read_bytes()
+        if len(data) > MAX_READ:
+            raise ValueError("file too large")
+        ctype = mimetypes.guess_type(str(abs_path))[0] or "application/octet-stream"
+        return data, ctype
+
+    def _purge(self) -> None:
+        now = time.time()
+        dead = [k for k, v in self._uploads.items() if now > float(v.get("deadline") or 0)]
+        for k in dead:
+            sess = self._uploads.pop(k, None)
+            if not sess:
+                continue
+            try:
+                fh = sess.get("file")
+                if fh:
+                    fh.close()
+                tmp = sess.get("tmp")
+                if tmp and Path(tmp).exists():
+                    Path(tmp).unlink()
+            except OSError:
+                pass
+
+    def _write_start(self, payload: dict[str, Any]) -> None:
+        upload_id = str(payload.get("upload_id") or payload.get("uploadId") or "").strip()
+        root = str(payload.get("root_path") or payload.get("rootPath") or "")
+        rel = str(payload.get("rel_path") or payload.get("relPath") or "")
+        total = int(payload.get("total_size") or payload.get("totalSize") or 0)
+        chunks = int(payload.get("chunk_count") or payload.get("chunkCount") or 0)
+        resp = {"request_id": str(payload.get("request_id") or "")}
+        try:
+            if not upload_id:
+                raise ValueError("upload id required")
+            if total <= 0 or total > MAX_READ:
+                raise ValueError("invalid upload size")
+            if chunks <= 0:
+                raise ValueError("chunk count required")
+            if not root:
+                raise ValueError("root path required")
+            abs_path = _resolve_under_root(root, rel)
+            with self._mu:
+                self._purge()
+                if upload_id in self._uploads:
+                    raise ValueError("upload session already exists")
+                abs_path.parent.mkdir(parents=True, exist_ok=True)
+                tmp = str(abs_path) + f".upload-{upload_id}"
+                fh = open(tmp, "wb")
+                self._uploads[upload_id] = {
+                    "abs": str(abs_path),
+                    "tmp": tmp,
+                    "file": fh,
+                    "total": total,
+                    "chunks": chunks,
+                    "next": 0,
+                    "written": 0,
+                    "deadline": time.time() + UPLOAD_TTL,
+                }
+        except Exception as e:
+            resp["error"] = str(e)
+        self._reply(resp)
+
+    def _write_chunk(self, payload: dict[str, Any]) -> None:
+        upload_id = str(payload.get("upload_id") or payload.get("uploadId") or "").strip()
+        idx = int(payload.get("chunk_index") or payload.get("chunkIndex") or -1)
+        resp = {"request_id": str(payload.get("request_id") or "")}
+        try:
+            raw = base64.b64decode(str(payload.get("body") or ""))
+            with self._mu:
+                self._purge()
+                sess = self._uploads.get(upload_id)
+                if not sess:
+                    raise ValueError("upload session not found")
+                if idx != int(sess["next"]):
+                    raise ValueError(f"unexpected chunk index {idx}")
+                fh = sess["file"]
+                fh.write(raw)
+                sess["written"] = int(sess["written"]) + len(raw)
+                sess["next"] = idx + 1
+                sess["deadline"] = time.time() + UPLOAD_TTL
+        except Exception as e:
+            resp["error"] = str(e)
+        self._reply(resp)
+
+    def _write_finish(self, payload: dict[str, Any]) -> dict[str, Any]:
+        upload_id = str(payload.get("upload_id") or payload.get("uploadId") or "").strip()
+        resp: dict[str, Any] = {"request_id": str(payload.get("request_id") or "")}
+        with self._mu:
+            self._purge()
+            sess = self._uploads.pop(upload_id, None)
+        if not sess:
+            resp["error"] = "upload session not found"
+            return resp
+        try:
+            fh = sess["file"]
+            fh.close()
+            tmp = Path(sess["tmp"])
+            abs_path = Path(sess["abs"])
+            if int(sess["written"]) != int(sess["total"]):
+                tmp.unlink(missing_ok=True)
+                raise ValueError("upload size mismatch")
+            if int(sess["next"]) != int(sess["chunks"]):
+                tmp.unlink(missing_ok=True)
+                raise ValueError("missing chunks")
+            os.replace(tmp, abs_path)
+        except Exception as e:
+            resp["error"] = str(e)
+        return resp

aicortexpy/artifacts.py

@@ -0,0 +1,67 @@
+"""Scan HTML artifacts and report metadata to the server."""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import Callable
+
+log = logging.getLogger("aicortexpy.artifacts")
+
+_SKIP_DIRS = {
+    "node_modules",
+    ".git",
+    ".next",
+    ".turbo",
+    "dist",
+    "build",
+    "__pycache__",
+    ".repos",
+}
+
+
+def scan_html_artifacts(work_dir: str | Path) -> list[dict[str, str]]:
+    root = Path(work_dir)
+    if not root.is_dir():
+        return []
+    items: list[dict[str, str]] = []
+    for path in root.rglob("*.html"):
+        if any(p in _SKIP_DIRS for p in path.parts):
+            continue
+        try:
+            rel = path.relative_to(root).as_posix()
+        except ValueError:
+            continue
+        title = _title_from_html(path) or path.stem
+        kind = "preview"
+        if "design" in path.parts:
+            kind = "design"
+        items.append({"rel_path": rel, "kind": kind, "title": title[:120]})
+        if len(items) >= 50:
+            break
+    return items
+
+
+def _title_from_html(path: Path) -> str:
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")[:8000]
+    except OSError:
+        return ""
+    m = re.search(r"<title[^>]*>(.*?)</title>", text, re.I | re.S)
+    if not m:
+        return ""
+    return re.sub(r"\s+", " ", m.group(1)).strip()
+
+
+def report_issue_artifacts(
+    work_dir: str,
+    report: Callable[[list[dict[str, str]]], None],
+) -> None:
+    items = scan_html_artifacts(work_dir)
+    if not items:
+        return
+    try:
+        report(items)
+    except Exception as e:
+        log.warning("report artifacts failed: %s", e)

aicortexpy/attachments.py

@@ -0,0 +1,85 @@
+"""Materialize chat attachments into workdir/_incoming."""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+
+from .client import DaemonClient, Task
+
+log = logging.getLogger("aicortexpy.attachments")
+
+INCOMING_DIR = "_incoming"
+_UNSAFE = re.compile(r'[<>:"|?*\\/]+')
+
+
+def sanitize_filename(name: str) -> str:
+    name = (name or "").replace("\\", "/").strip()
+    name = name.rsplit("/", 1)[-1].strip()
+    if not name or name in (".", ".."):
+        return ""
+    return _UNSAFE.sub("_", name)
+
+
+def unique_filename(name: str, used: set[str]) -> str:
+    if name not in used:
+        used.add(name)
+        return name
+    stem, dot, ext = name.partition(".")
+    if not dot:
+        stem, ext = name, ""
+    else:
+        # keep full extension (e.g. .tar.gz → use last suffix only for simplicity)
+        parts = name.rsplit(".", 1)
+        stem, ext = parts[0], "." + parts[1]
+    i = 2
+    while True:
+        cand = f"{stem}-{i}{ext}"
+        if cand not in used:
+            used.add(cand)
+            return cand
+        i += 1
+
+
+def materialize_attachments(
+    client: DaemonClient,
+    task: Task,
+    work_dir: Path,
+) -> list[str]:
+    """Download attachments into work_dir/_incoming. Returns relative paths."""
+    atts = task.chat_message_attachments
+    if not atts:
+        return []
+    incoming = work_dir / INCOMING_DIR
+    incoming.mkdir(parents=True, exist_ok=True)
+    used: set[str] = set()
+    rel_paths: list[str] = []
+
+    for att in atts:
+        att_id = str(att.get("id") or "")
+        if not att_id:
+            continue
+        try:
+            body, header_name = client.fetch_attachment_bytes(att_id)
+        except Exception as e:
+            log.warning("fetch attachment failed id=%s: %s", att_id, e)
+            continue
+        name = sanitize_filename(str(att.get("filename") or "")) or sanitize_filename(
+            header_name
+        )
+        if not name:
+            name = att_id
+        name = unique_filename(name, used)
+        rel = f"{INCOMING_DIR}/{name}"
+        abs_path = work_dir / INCOMING_DIR / name
+        try:
+            abs_path.write_bytes(body)
+        except OSError as e:
+            log.warning("write attachment failed path=%s: %s", rel, e)
+            continue
+        rel_paths.append(rel)
+        log.info("materialized attachment id=%s path=%s bytes=%s", att_id, rel, len(body))
+
+    task.design_incoming_rel_paths = rel_paths
+    return rel_paths

aicortexpy/auto_commit.py

@@ -0,0 +1,106 @@
+"""Best-effort auto-commit after successful agent runs."""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+log = logging.getLogger("aicortexpy.auto_commit")
+
+EXCLUDE = [
+    "node_modules",
+    ".next",
+    ".turbo",
+    "__pycache__",
+    "target",
+    "dist",
+    "build",
+    ".cache",
+    "*.pyc",
+    "*.o",
+    "*.so",
+    "*.dylib",
+    ".env",
+    ".env.local",
+]
+
+
+def _git(cwd: Path, *args: str) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        capture_output=True,
+        text=True,
+        timeout=120,
+        check=False,
+    )
+    return proc.returncode, proc.stdout or "", proc.stderr or ""
+
+
+def _is_git_repo(work_dir: Path) -> bool:
+    git = work_dir / ".git"
+    if git.is_dir():
+        return True
+    if git.is_file():
+        try:
+            return git.read_text(encoding="utf-8", errors="replace").startswith("gitdir:")
+        except OSError:
+            return False
+    # walk up a bit for nested checkouts
+    code, out, _ = _git(work_dir, "rev-parse", "--is-inside-work-tree")
+    return code == 0 and "true" in out.lower()
+
+
+def ensure_git_exclude(work_dir: Path) -> None:
+    exclude = work_dir / ".git" / "info" / "exclude"
+    if not exclude.parent.is_dir():
+        return
+    try:
+        existing = exclude.read_text(encoding="utf-8") if exclude.is_file() else ""
+    except OSError:
+        return
+    lines = existing.splitlines()
+    changed = False
+    for pat in EXCLUDE:
+        if pat not in lines:
+            lines.append(pat)
+            changed = True
+    if changed:
+        try:
+            exclude.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        except OSError as e:
+            log.warning("write exclude failed: %s", e)
+
+
+def auto_commit_and_push(work_dir: str, task_id: str, agent_name: str) -> None:
+    if not work_dir:
+        return
+    path = Path(work_dir)
+    if not path.is_dir() or not _is_git_repo(path):
+        return
+    ensure_git_exclude(path)
+    code, status, err = _git(path, "status", "--porcelain")
+    if code != 0:
+        log.warning("auto-commit: status failed: %s", err)
+        return
+    if not status.strip():
+        return
+    code, _, err = _git(path, "add", "-A")
+    if code != 0:
+        log.warning("auto-commit: add failed: %s", err)
+        return
+    code, _, _ = _git(path, "diff", "--cached", "--quiet")
+    if code == 0:
+        return
+    msg = f"aicortex: auto-commit after task {task_id[:8]} ({agent_name})"
+    code, _, err = _git(path, "commit", "-m", msg)
+    if code != 0:
+        log.warning("auto-commit: commit failed: %s", err)
+        return
+    log.info("auto-commit: committed in %s", work_dir)
+    code, _, err = _git(path, "push")
+    if code != 0:
+        log.debug("auto-commit: push skipped/failed: %s", err[:200])
+    else:
+        log.info("auto-commit: pushed")