aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/execenv.py

@@ -0,0 +1,264 @@
+"""Per-task execution environment preparation."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .client import Task
+from .codex_config import ensure_codex_multi_agent_config, sanitize_copied_codex_config
+from .openclaw_config import prepare_openclaw_config
+from .pinned_workdir import prepare_pinned_workdir, project_uses_pinned_workdir
+from .prompt import build_prompt
+from .runtime_config import (
+    inject_runtime_config,
+    task_context_from_task,
+    write_project_sidecar,
+)
+from .sandbox import codex_sandbox_policy, prepare_provider_sandbox, write_codex_sandbox_config
+
+log = logging.getLogger("aicortexpy.execenv")
+
+
+@dataclass
+class Environment:
+    root_dir: Path
+    work_dir: Path
+    codex_home: Path | None = None
+    pinned: bool = False
+    env_updates: dict[str, str] = field(default_factory=dict)
+    runtime_brief: str = ""
+
+
+def provider_needs_inline_system_prompt(provider: str) -> bool:
+    """Match Go daemon.providerNeedsInlineSystemPrompt (openclaw/kiro/kimi)."""
+    return provider in ("openclaw", "kiro", "kimi")
+
+
+def _workdir_accessible(path: Path) -> bool:
+    try:
+        return path.is_dir()
+    except OSError:
+        return False
+
+
+def prepare_environment(
+    workspaces_root: Path,
+    task: Task,
+    provider: str,
+) -> Environment:
+    ws = task.workspace_id or "default"
+    env_updates: dict[str, str] = {}
+
+    if project_uses_pinned_workdir(task):
+        work_dir = prepare_pinned_workdir(workspaces_root, task)
+        root_dir = work_dir
+        pinned = True
+    else:
+        pinned = False
+        prior = (task.prior_work_dir or "").strip()
+        prior_path = Path(prior) if prior else None
+        if prior_path is not None and _workdir_accessible(prior_path):
+            work_dir = prior_path
+            root_dir = prior_path.parent
+            log.info("reusing prior workdir %s", work_dir)
+        else:
+            if prior:
+                log.warning(
+                    "prior workdir unavailable, preparing fresh env path=%s",
+                    prior,
+                )
+            root_dir = workspaces_root / ws / task.id
+            work_dir = root_dir / "workdir"
+            for d in (work_dir, root_dir / "output", root_dir / "logs"):
+                d.mkdir(parents=True, exist_ok=True)
+
+    prompt = build_prompt(task, provider)
+    (work_dir / "PROMPT.md").write_text(prompt, encoding="utf-8")
+
+    agent = task.agent or {}
+    ctx = task_context_from_task(task)
+    runtime_brief = inject_runtime_config(work_dir, provider, ctx)
+    write_project_sidecar(work_dir, ctx)
+
+    if task.project_prompt:
+        (work_dir / "PROJECT.md").write_text(task.project_prompt, encoding="utf-8")
+
+    write_agent_skills(work_dir, provider, agent.get("skills"))
+    inject_default_skills(work_dir, provider)
+
+    codex_home: Path | None = None
+    if provider == "codex":
+        codex_home = root_dir / "codex-home" if not pinned else work_dir / ".codex-home"
+        policy = codex_sandbox_policy()
+        write_codex_sandbox_config(codex_home, policy)
+        hydrate_codex_home(codex_home, agent.get("skills"))
+        # Codex discovers skills from CODEX_HOME/skills — mirror default skills there too.
+        _copy_defaults_into(codex_home / "skills")
+        # prepare_provider_sandbox may rewrite config.toml — apply multi_agent last.
+        prepare_provider_sandbox(provider, work_dir)
+        ensure_codex_multi_agent_config(codex_home / "config.toml")
+        sanitize_copied_codex_config(codex_home / "config.toml")
+
+    if provider == "openclaw":
+        oc = prepare_openclaw_config(root_dir, work_dir)
+        if oc.env_updates:
+            env_updates.update(oc.env_updates)
+
+    return Environment(
+        root_dir=root_dir,
+        work_dir=work_dir,
+        codex_home=codex_home,
+        pinned=pinned,
+        env_updates=env_updates,
+        runtime_brief=runtime_brief,
+    )
+
+
+def write_agent_skills(work_dir: Path, provider: str, skills: Any) -> None:
+    if not isinstance(skills, list):
+        return
+    base = _skills_root(work_dir, provider)
+    base.mkdir(parents=True, exist_ok=True)
+    for sk in skills:
+        if not isinstance(sk, dict):
+            continue
+        name = str(sk.get("name") or "skill").strip() or "skill"
+        safe = "".join(c if c.isalnum() or c in "-_" else "-" for c in name)
+        skill_dir = base / safe
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        content = str(sk.get("content") or "")
+        (skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
+        files = sk.get("files")
+        if isinstance(files, list):
+            for f in files:
+                if not isinstance(f, dict):
+                    continue
+                rel = str(f.get("path") or "").lstrip("/\\")
+                if not rel or ".." in rel.split("/"):
+                    continue
+                dest = skill_dir / rel
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                dest.write_text(str(f.get("content") or ""), encoding="utf-8")
+
+
+def inject_default_skills(work_dir: Path, provider: str) -> None:
+    dest = _skills_root(work_dir, provider)
+    for src_root in _default_skill_roots():
+        _copy_default_skill_dirs(src_root, dest)
+
+
+def _copy_defaults_into(dest_root: Path) -> None:
+    for src_root in _default_skill_roots():
+        _copy_default_skill_dirs(src_root, dest_root)
+
+
+def _default_skill_roots() -> list[Path]:
+    roots: list[Path] = []
+    bundled = Path(__file__).resolve().parent / "data" / "default_skills"
+    if bundled.is_dir():
+        roots.append(bundled)
+    # Monorepo sibling (dev / source checkout): reuse Go daemon defaultskills.
+    mono = (
+        Path(__file__).resolve().parents[2]
+        / "server"
+        / "internal"
+        / "daemon"
+        / "defaultskills"
+    )
+    if mono.is_dir():
+        roots.append(mono)
+    return roots
+
+
+def _copy_default_skill_dirs(src_root: Path, dest_root: Path) -> None:
+    dest_root.mkdir(parents=True, exist_ok=True)
+    skip_heavy = (os.environ.get("AICORTEX_INJECT_TENCENT_DOCS") or "").strip().lower() not in (
+        "1",
+        "true",
+        "yes",
+        "on",
+    )
+    for child in src_root.iterdir():
+        if not child.is_dir():
+            continue
+        # Skip Go package helper dirs / tests and huge tencent bundle by default.
+        if child.name in ("testdata",):
+            continue
+        if skip_heavy and child.name == "tencent-docs":
+            # Still inject SKILL.md alone so the skill is discoverable.
+            skill_md = child / "SKILL.md"
+            if skill_md.is_file():
+                target = dest_root / child.name
+                target.mkdir(parents=True, exist_ok=True)
+                dest_md = target / "SKILL.md"
+                if not dest_md.exists():
+                    try:
+                        shutil.copy2(skill_md, dest_md)
+                    except OSError as e:
+                        log.warning("copy tencent-docs SKILL.md failed: %s", e)
+            continue
+        if not (child / "SKILL.md").is_file():
+            continue
+        target = dest_root / child.name
+        if target.exists():
+            continue
+        try:
+            shutil.copytree(child, target)
+        except OSError as e:
+            log.warning("copy default skill %s failed: %s", child.name, e)
+
+
+def hydrate_codex_home(codex_home: Path, skills: Any) -> None:
+    user = Path.home() / ".codex"
+    codex_home.mkdir(parents=True, exist_ok=True)
+    for name in ("auth.json", "config.toml"):
+        src = user / name
+        dst = codex_home / name
+        if src.is_file() and not dst.exists():
+            try:
+                shutil.copy2(src, dst)
+            except OSError:
+                pass
+    cfg = codex_home / "config.toml"
+    sanitize_copied_codex_config(cfg)
+
+    skills_dir = codex_home / "skills"
+    skills_dir.mkdir(parents=True, exist_ok=True)
+    if isinstance(skills, list):
+        for sk in skills:
+            if not isinstance(sk, dict):
+                continue
+            name = str(sk.get("name") or "skill")
+            safe = "".join(c if c.isalnum() or c in "-_" else "-" for c in name)
+            d = skills_dir / safe
+            d.mkdir(parents=True, exist_ok=True)
+            (d / "SKILL.md").write_text(str(sk.get("content") or ""), encoding="utf-8")
+
+
+def _skills_root(work_dir: Path, provider: str) -> Path:
+    if provider == "claude":
+        return work_dir / ".claude" / "skills"
+    if provider == "cursor":
+        return work_dir / ".cursor" / "skills"
+    if provider == "copilot":
+        return work_dir / ".github" / "skills"
+    if provider == "opencode":
+        return work_dir / ".opencode" / "skills"
+    if provider == "openclaw":
+        return work_dir / "skills"
+    if provider == "pi":
+        return work_dir / ".pi" / "skills"
+    if provider == "kimi":
+        return work_dir / ".kimi" / "skills"
+    if provider == "kiro":
+        return work_dir / ".kiro" / "skills"
+    if provider == "dsh":
+        return work_dir / ".dsh" / "skills"
+    # codex / gemini / hermes / unknown → meta skill references .agent_context/skills
+    # (Codex also gets skills under per-task CODEX_HOME/skills via hydrate_codex_home)
+    return work_dir / ".agent_context" / "skills"

aicortexpy/gc.py

@@ -0,0 +1,286 @@
+"""Periodic workspace GC."""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import threading
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .client import APIError, DaemonClient, is_not_found
+
+log = logging.getLogger("aicortexpy.gc")
+
+META_NAME = ".gc_meta.json"
+LEGACY_META_NAME = ".aicortex-gc.json"
+ARTIFACT_PATTERNS = ("node_modules", ".next", ".turbo")
+
+
+class ActiveEnvRoots:
+    """Refcounted set of env roots currently used by running tasks (Go activeEnvRoots)."""
+
+    def __init__(self) -> None:
+        self._mu = threading.Lock()
+        self._roots: dict[str, int] = {}
+
+    @staticmethod
+    def _key(path: str | Path) -> str:
+        try:
+            return str(Path(path).resolve())
+        except OSError:
+            return str(path)
+
+    def mark(self, path: str | Path) -> None:
+        key = self._key(path)
+        if not key:
+            return
+        with self._mu:
+            self._roots[key] = self._roots.get(key, 0) + 1
+
+    def unmark(self, path: str | Path) -> None:
+        key = self._key(path)
+        if not key:
+            return
+        with self._mu:
+            n = self._roots.get(key, 0)
+            if n <= 1:
+                self._roots.pop(key, None)
+            else:
+                self._roots[key] = n - 1
+
+    def is_active(self, path: str | Path) -> bool:
+        key = self._key(path)
+        with self._mu:
+            return self._roots.get(key, 0) > 0
+
+
+def write_gc_meta(env_root: Path, meta: dict[str, Any]) -> None:
+    try:
+        (env_root / META_NAME).write_text(
+            json.dumps(meta, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+        legacy = env_root / LEGACY_META_NAME
+        if legacy.is_file():
+            try:
+                legacy.unlink()
+            except OSError:
+                pass
+    except OSError as e:
+        log.warning("write gc meta failed: %s", e)
+
+
+def read_gc_meta(task_dir: Path) -> dict[str, Any] | None:
+    for name in (META_NAME, LEGACY_META_NAME):
+        path = task_dir / name
+        if not path.is_file():
+            continue
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if isinstance(data, dict):
+            return data
+    return None
+
+
+def gc_meta_for_task(
+    task_id: str,
+    issue_id: str,
+    chat_id: str,
+    autopilot_id: str,
+    *,
+    workspace_id: str = "",
+    quick_create: bool = False,
+) -> dict[str, Any]:
+    """Align with Go execenv.GCMeta field names (+ parent_id for local helpers)."""
+    completed = datetime.now(timezone.utc).isoformat()
+    if issue_id:
+        return {
+            "kind": "issue",
+            "issue_id": issue_id,
+            "parent_id": issue_id,
+            "task_id": task_id,
+            "workspace_id": workspace_id,
+            "completed_at": completed,
+        }
+    if chat_id:
+        return {
+            "kind": "chat",
+            "chat_session_id": chat_id,
+            "parent_id": chat_id,
+            "task_id": task_id,
+            "workspace_id": workspace_id,
+            "completed_at": completed,
+        }
+    if autopilot_id:
+        return {
+            "kind": "autopilot_run",
+            "autopilot_run_id": autopilot_id,
+            "parent_id": autopilot_id,
+            "task_id": task_id,
+            "workspace_id": workspace_id,
+            "completed_at": completed,
+        }
+    if quick_create:
+        return {
+            "kind": "quick_create",
+            "parent_id": task_id,
+            "task_id": task_id,
+            "workspace_id": workspace_id,
+            "completed_at": completed,
+        }
+    return {
+        "kind": "task",
+        "parent_id": task_id,
+        "task_id": task_id,
+        "workspace_id": workspace_id,
+        "completed_at": completed,
+    }
+
+
+def _meta_parent(meta: dict[str, Any]) -> tuple[str, str]:
+    kind = str(meta.get("kind") or "")
+    if kind == "issue":
+        return kind, str(meta.get("issue_id") or meta.get("parent_id") or "")
+    if kind == "chat":
+        return kind, str(meta.get("chat_session_id") or meta.get("parent_id") or "")
+    if kind in ("autopilot", "autopilot_run"):
+        return "autopilot", str(meta.get("autopilot_run_id") or meta.get("parent_id") or "")
+    if kind == "quick_create":
+        return kind, str(meta.get("task_id") or meta.get("parent_id") or "")
+    return kind or "task", str(meta.get("parent_id") or meta.get("task_id") or "")
+
+
+def run_gc_loop(
+    stop: threading.Event,
+    client: DaemonClient,
+    workspaces_root: Path,
+    *,
+    interval: float,
+    ttl: float,
+    orphan_ttl: float,
+    artifact_ttl: float,
+    enabled: bool,
+    active_roots: ActiveEnvRoots | None = None,
+) -> None:
+    if not enabled:
+        log.info("gc: disabled")
+        return
+    log.info("gc: started interval=%ss ttl=%ss", interval, ttl)
+    stop.wait(30.0)
+    while not stop.is_set():
+        try:
+            run_gc_once(
+                client,
+                workspaces_root,
+                ttl,
+                orphan_ttl,
+                artifact_ttl,
+                active_roots=active_roots,
+            )
+        except Exception as e:
+            log.warning("gc cycle failed: %s", e)
+        stop.wait(interval)
+
+
+def run_gc_once(
+    client: DaemonClient,
+    workspaces_root: Path,
+    ttl: float,
+    orphan_ttl: float,
+    artifact_ttl: float,
+    *,
+    active_roots: ActiveEnvRoots | None = None,
+) -> None:
+    if not workspaces_root.is_dir():
+        return
+    now = time.time()
+    cleaned = orphaned = artifact_dirs = skipped_active = 0
+    for ws in workspaces_root.iterdir():
+        if not ws.is_dir() or ws.name in (".repos",):
+            continue
+        for child in ws.iterdir():
+            if not child.is_dir():
+                continue
+            if child.name == "projects":
+                continue  # pinned project roots — never GC
+            if active_roots is not None and active_roots.is_active(child):
+                skipped_active += 1
+                continue
+
+            age = now - child.stat().st_mtime
+            meta = read_gc_meta(child)
+
+            if meta is None:
+                if age >= orphan_ttl:
+                    _rm(child)
+                    orphaned += 1
+                continue
+
+            kind, parent = _meta_parent(meta)
+            try:
+                status_info = _status_for(client, kind, parent)
+            except APIError as e:
+                if is_not_found(e, "not found") and age >= orphan_ttl:
+                    _rm(child)
+                    orphaned += 1
+                continue
+            except Exception:
+                continue
+
+            status = str(status_info.get("status") or "").lower()
+            # Chat sessions that are still active must never be reclaimed.
+            if kind == "chat" and status in ("active", "open", ""):
+                continue
+            terminal = status in ("done", "cancelled", "completed", "failed", "archived")
+            if terminal and age >= ttl:
+                _rm(child)
+                cleaned += 1
+                continue
+
+            # artifact reclaim on still-open parents
+            if artifact_ttl > 0 and age >= artifact_ttl:
+                if _reclaim_artifacts(child):
+                    artifact_dirs += 1
+
+    if cleaned or orphaned or artifact_dirs or skipped_active:
+        log.info(
+            "gc: cleaned=%s orphaned=%s artifact_dirs=%s skipped_active=%s",
+            cleaned,
+            orphaned,
+            artifact_dirs,
+            skipped_active,
+        )
+
+
+def _status_for(client: DaemonClient, kind: str, parent: str) -> dict[str, Any]:
+    if kind == "issue":
+        return client.get_issue_gc_check(parent)
+    if kind == "chat":
+        return client.get_chat_session_gc_check(parent)
+    if kind == "autopilot":
+        return client.get_autopilot_run_gc_check(parent)
+    return client.get_task_gc_check(parent)
+
+
+def _reclaim_artifacts(root: Path) -> bool:
+    removed = False
+    for pat in ARTIFACT_PATTERNS:
+        for hit in root.rglob(pat):
+            if hit.is_dir() and hit.name == pat:
+                _rm(hit)
+                removed = True
+    return removed
+
+
+def _rm(path: Path) -> None:
+    try:
+        shutil.rmtree(path, ignore_errors=True)
+        log.info("gc: removed %s", path)
+    except OSError as e:
+        log.warning("gc: remove failed %s: %s", path, e)

aicortexpy/handoff_bundle.py

@@ -0,0 +1,65 @@
+"""Download + extract design→dev handoff zip bundles."""
+
+from __future__ import annotations
+
+import io
+import logging
+import zipfile
+from pathlib import Path
+from typing import Any
+from urllib.request import Request, urlopen
+
+log = logging.getLogger("aicortexpy.handoff")
+
+MAX_BYTES = 50 << 20
+
+
+def download_handoff_bundle(
+    url: str,
+    *,
+    token: str = "",
+    server_base: str = "",
+    timeout: float = 120.0,
+) -> bytes:
+    url = (url or "").strip()
+    if not url:
+        raise ValueError("handoff bundle url is empty")
+    req = Request(url, method="GET")
+    if token and server_base and url.startswith(server_base.rstrip("/")):
+        req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("X-Client-Platform", "daemon")
+    with urlopen(req, timeout=timeout) as resp:  # noqa: S310 — intentional HTTP fetch
+        data = resp.read(MAX_BYTES + 1)
+    if len(data) > MAX_BYTES:
+        raise ValueError("handoff bundle exceeds size limit")
+    return data
+
+
+def extract_zip_archive(data: bytes, dest_dir: Path) -> None:
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest_root = dest_dir.resolve()
+    with zipfile.ZipFile(io.BytesIO(data)) as zf:
+        for info in zf.infolist():
+            if info.is_dir():
+                continue
+            name = info.filename.replace("\\", "/")
+            if name.startswith("/") or ".." in name.split("/"):
+                raise ValueError(f"unsafe zip path: {info.filename}")
+            target = (dest_dir / name).resolve()
+            if not str(target).startswith(str(dest_root)):
+                raise ValueError(f"zip slip blocked: {info.filename}")
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(zf.read(info))
+
+
+def materialize_handoff_bundle(
+    work_dir: Path,
+    bundle_url: str,
+    *,
+    token: str = "",
+    server_base: str = "",
+) -> None:
+    log.info("downloading handoff bundle url=%s", bundle_url)
+    data = download_handoff_bundle(bundle_url, token=token, server_base=server_base)
+    extract_zip_archive(data, work_dir)
+    log.info("handoff bundle extracted to %s", work_dir)