aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/capabilities.py

@@ -0,0 +1,92 @@
+"""Go daemon capability inventory vs Python daemon status."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Capability:
+    id: str
+    name: str
+    go_ref: str
+    status: str
+    python_note: str
+    sandbox_note: str = ""
+
+
+CAPABILITIES: list[Capability] = [
+    Capability("register", "Register runtimes per workspace", "daemon.go", "done", "OK"),
+    Capability("deregister", "Deregister on shutdown", "daemon.go", "done", "OK"),
+    Capability("workspace_sync", "Periodic workspace discovery", "workspaceSyncLoop", "done", "30s sync + re-register empty"),
+    Capability("runtime_gone", "Recover when server deletes runtime", "handleRuntimeGone", "done", "404 heartbeat → backoff re-register"),
+    Capability("identity", "Stable daemon_id / device_name / X-Client-*", "identity.go", "done", "OK"),
+    Capability("health", "Local health + shutdown + /repo/checkout", "health.go", "done", "19514 (+ profile offset); allowlist checkout"),
+    Capability("background", "Detach start/stop/status", "cmd_daemon_*", "done", "Win/macOS/Linux; --backend python"),
+    Capability("poll_claim", "Poll claim tasks", "pollLoop", "done", "OK"),
+    Capability("wakeup_ws", "WebSocket wakeup + sidebands", "wakeup.go", "done", "task + tunnel + artifact + terminal mux"),
+    Capability("start_complete_fail", "start / progress / complete / fail", "client.go", "done", "OK"),
+    Capability("cancel_watch", "Cancel mid-run via status poll", "watchTaskCancellation", "done", "kill process tree"),
+    Capability("messages_usage", "Report stream messages + token usage", "ReportTaskMessages/Usage", "done", "claude/cursor/gemini/opencode/copilot + ACP"),
+    Capability("prompt_build", "Rich prompt templates", "prompt.go", "done", "templates + reply_instructions"),
+    Capability("recover_orphans", "Recover orphans on register", "RecoverOrphans", "done", "OK"),
+    Capability("execenv_prepare", "Per-task env + skills", "execenv.Prepare", "done", "prior reuse + agentEnv + handoff/seed"),
+    Capability("runtime_meta", "CLAUDE.md/AGENTS.md/GEMINI.md meta skill", "runtime_config.go", "done", "runtime_config.py"),
+    Capability("codex_home", "Per-task CODEX_HOME", "codex_home.go", "done", "hydrate + skill strip + multi_agent off"),
+    Capability("openclaw_config", "Per-task OpenClaw config wrap", "openclaw_config.go", "done", "fail-closed + full agent entry rewrite"),
+    Capability("repo_cache", "Bare cache + worktree checkout", "repocache/", "done", "per-ws bare + lock + worktree + co-authored hook"),
+    Capability("pinned_workdir", "Pinned project workdir", "pinned_workdir.go", "done", "projects/<id> stages"),
+    Capability("attachments", "Materialize attachments", "materialize_attachments.go", "done", "_incoming/"),
+    Capability("auto_commit", "Auto-commit agent changes", "auto_commit.go", "done", "best-effort commit/push"),
+    Capability("artifacts", "Artifacts metadata + WS browse/chunk", "artifact/", "done", "scan metadata + wakeup artifact ops"),
+    Capability("agent_claude", "Claude stream-json backend", "claude.go", "done", "stream-json + resume + mcp-config"),
+    Capability("agent_codex", "Codex exec backend", "codex.go", "done", "codex exec + CODEX_HOME + semantic inactivity"),
+    Capability("agent_others", "Other provider CLIs", "pkg/agent", "done", "openclaw/pi/opencode/copilot/cursor/gemini"),
+    Capability(
+        "chat_acp_pool",
+        "ACP connection pool",
+        "chat_acp_pool.go",
+        "done",
+        "Cursor/Kiro chat pool; kiro/hermes/kimi/dsh oneshot ACP",
+    ),
+    Capability(
+        "agent_acp_oneshot",
+        "ACP one-shot backends",
+        "kiro.go/hermes.go/kimi.go/dsh.go",
+        "done",
+        "JSON-RPC + tool stream + stderr promote + idle watchdog",
+    ),
+    Capability("model_list", "Heartbeat model discovery", "handleModelList", "done", "CLI + ACP discovery + 60s cache"),
+    Capability("local_skills", "List/import local skills", "local_skills.go", "done", "local_skills.py"),
+    Capability("default_skills", "Bundled default skills", "defaultskills/", "done", "bundled + monorepo sync"),
+    Capability("heartbeat", "Runtime heartbeat + actions", "heartbeatLoop", "done", "model/skills; skip update"),
+    Capability("auto_update", "Self-update CLI binary", "auto_update.go", "n/a", "use pip"),
+    Capability("gc", "Workspace GC / diskusage", "gc.go", "done", ".gc_meta.json + active-root guard"),
+    Capability("poisoned", "Poisoned-task quarantine", "poisoned.go", "done", "failure_reason classifiers"),
+    Capability("terminal_pty", "Remote terminal", "terminal_*.go", "partial", "pipe-shell MVP; aicortex_TERMINAL_PTY"),
+    Capability("tunnel_proxy", "Loopback HTTP tunnel", "tunnel/proxy.go", "done", "tunnel.py via wakeup WS"),
+    Capability("handoff_bundle", "Design handoff bundle", "handoff_bundle.go", "done", "download+extract zip"),
+    Capability("design_seed", "Design example seed", "design.SeedExample*", "done", "bundle copy + marker"),
+    Capability("sandbox_agent_native", "Provider-native sandbox", "codex_sandbox.go", "partial", "Codex config; Claude flags thin"),
+    Capability("sandbox_wrapper", "Optional OS wrapper", "sandbox-runtime", "partial", "bwrap/Seatbelt optional; Win n/a"),
+]
+
+
+def by_status() -> dict[str, list[Capability]]:
+    out: dict[str, list[Capability]] = {}
+    for c in CAPABILITIES:
+        out.setdefault(c.status, []).append(c)
+    return out
+
+
+def format_table() -> str:
+    order = ["done", "partial", "planned", "hard", "defer", "n/a"]
+    lines = [f"{'STATUS':<8} {'ID':<22} {'NAME'}", "-" * 72]
+    grouped = by_status()
+    for st in order:
+        for c in grouped.get(st, []):
+            lines.append(f"{c.status:<8} {c.id:<22} {c.name}")
+    counts = {st: len(grouped.get(st, [])) for st in order}
+    lines.append("-" * 72)
+    lines.append("counts: " + ", ".join(f"{st}={counts[st]}" for st in order if counts[st]))
+    return "\n".join(lines)

aicortexpy/chat_acp_pool.py

@@ -0,0 +1,321 @@
+"""Pooled Cursor/Kiro ACP connections for multi-turn chat sessions."""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from .acp_conn import (
+    ACPChatConn,
+    ACPPromptResult,
+    CursorACPConn,
+    KiroACPConn,
+    cursor_acp_supported,
+    kiro_acp_supported,
+)
+from .config import AgentEntry, Config
+
+log = logging.getLogger("aicortexpy.acp_pool")
+
+
+@dataclass
+class _PoolEntry:
+    key: str
+    provider: str
+    chat_id: str
+    agent_id: str
+    work_dir: str
+    model: str
+    conn: ACPChatConn | None = None
+    last_used: float = field(default_factory=time.time)
+    turn_lock: threading.Lock = field(default_factory=threading.Lock)
+
+
+class ChatACPPool:
+    def __init__(
+        self,
+        *,
+        cursor_enabled: bool,
+        kiro_enabled: bool,
+        idle_timeout: float,
+        max_entries: int,
+        agents: dict[str, AgentEntry],
+    ) -> None:
+        self._agents = agents
+        self.idle_timeout = idle_timeout if idle_timeout > 0 else 300.0
+        self.max_entries = max_entries if max_entries > 0 else 50
+        self._lock = threading.Lock()
+        self._entries: dict[str, _PoolEntry] = {}
+
+        cursor_ok = False
+        if cursor_enabled:
+            entry = agents.get("cursor")
+            cursor_ok = bool(entry) and cursor_acp_supported(entry.path)
+        self.cursor_enabled = cursor_ok
+
+        kiro_ok = False
+        if kiro_enabled:
+            entry = agents.get("kiro")
+            kiro_ok = bool(entry) and kiro_acp_supported(entry.path)
+        self.kiro_enabled = kiro_ok
+
+        if self.cursor_enabled:
+            log.info("chat ACP pool: cursor enabled")
+        if self.kiro_enabled:
+            log.info("chat ACP pool: kiro enabled")
+
+    @classmethod
+    def from_config(cls, cfg: Config) -> ChatACPPool:
+        return cls(
+            cursor_enabled=cfg.cursor_acp_enabled,
+            kiro_enabled=cfg.kiro_acp_enabled,
+            idle_timeout=cfg.chat_acp_idle_timeout,
+            max_entries=cfg.chat_acp_max_connections,
+            agents=cfg.agents,
+        )
+
+    def enabled_for(self, provider: str) -> bool:
+        if provider == "cursor":
+            return self.cursor_enabled
+        if provider == "kiro":
+            return self.kiro_enabled
+        return False
+
+    def run_prompt(
+        self,
+        *,
+        provider: str,
+        chat_session_id: str,
+        agent_id: str,
+        work_dir: str,
+        model: str,
+        prompt: str,
+        resume_session_id: str,
+        custom_args: list[str],
+        timeout: float,
+        env: dict[str, str] | None = None,
+        cancel_event: threading.Event | None = None,
+        on_message: Any | None = None,
+        idle_watchdog: float = 0,
+        system_prompt: str = "",
+    ) -> ACPPromptResult:
+        key = pool_key(provider, chat_session_id, agent_id, work_dir)
+        entry = self._get_or_create(key, provider, chat_session_id, agent_id, work_dir, model)
+        with entry.turn_lock:
+            if entry.conn is None or entry.model != model:
+                if entry.conn is not None:
+                    try:
+                        entry.conn.close()
+                    except Exception:
+                        pass
+                    entry.conn = None
+                try:
+                    entry.conn = self._open_conn(
+                        provider,
+                        work_dir=work_dir,
+                        model=model,
+                        resume_session_id=resume_session_id,
+                        custom_args=custom_args,
+                        timeout=timeout,
+                        env=env,
+                    )
+                    entry.model = model
+                    log.info("%s chat acp pool miss chat=%s", provider, chat_session_id[:8])
+                except Exception as e:
+                    self.remove_entry(key)
+                    return ACPPromptResult(
+                        status="failed",
+                        output="",
+                        error=f"{provider} chat acp open failed: {e}",
+                    )
+            else:
+                log.info("%s chat acp pool hit chat=%s", provider, chat_session_id[:8])
+
+            entry.last_used = time.time()
+            assert entry.conn is not None
+
+            result = entry.conn.run_prompt(
+                prompt,
+                timeout=timeout or 20 * 60,
+                system_prompt=system_prompt,
+                on_message=on_message,
+                idle_watchdog=idle_watchdog,
+                cancel_event=cancel_event,
+            )
+
+            if not result.session_id and entry.conn.session_id():
+                result.session_id = entry.conn.session_id()
+
+            if _should_evict(result):
+                log.info(
+                    "%s chat acp pool evicting after interrupt status=%s",
+                    provider,
+                    result.status,
+                )
+                self.remove_entry(key)
+            elif result.status == "failed" and resume_session_id and not result.session_id:
+                log.warning("%s chat acp resume failed, evicting pool entry", provider)
+                self.remove_entry(key)
+            else:
+                entry.last_used = time.time()
+            return result
+
+    def _open_conn(
+        self,
+        provider: str,
+        *,
+        work_dir: str,
+        model: str,
+        resume_session_id: str,
+        custom_args: list[str],
+        timeout: float,
+        env: dict[str, str] | None,
+    ) -> ACPChatConn:
+        entry = self._agents.get(provider)
+        if not entry:
+            raise RuntimeError(f"no agent configured for {provider}")
+        if provider == "cursor":
+            return CursorACPConn.open(
+                entry.path,
+                cwd=work_dir,
+                model=model or entry.model,
+                resume_session_id="",  # never load for cursor chat
+                custom_args=custom_args,
+                timeout=timeout,
+                env=env,
+            )
+        if provider == "kiro":
+            return KiroACPConn.open(
+                entry.path,
+                cwd=work_dir,
+                model=model or entry.model,
+                resume_session_id=resume_session_id,
+                custom_args=custom_args,
+                timeout=timeout,
+                env=env,
+            )
+        raise RuntimeError(f"chat acp pool: unsupported provider {provider!r}")
+
+    def _get_or_create(
+        self,
+        key: str,
+        provider: str,
+        chat_id: str,
+        agent_id: str,
+        work_dir: str,
+        model: str,
+    ) -> _PoolEntry:
+        stale: list[ACPChatConn] = []
+        with self._lock:
+            stale.extend(self._take_idle_locked(time.time()))
+            if key in self._entries:
+                e = self._entries[key]
+            else:
+                if len(self._entries) >= self.max_entries:
+                    stale.extend(self._take_oldest_locked())
+                e = _PoolEntry(
+                    key=key,
+                    provider=provider,
+                    chat_id=chat_id,
+                    agent_id=agent_id,
+                    work_dir=work_dir,
+                    model=model,
+                )
+                self._entries[key] = e
+        _close_conns(stale)
+        return e
+
+    def remove_entry(self, key: str) -> None:
+        with self._lock:
+            e = self._entries.pop(key, None)
+            conn = e.conn if e else None
+            if e:
+                e.conn = None
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+    def evict_chat_session(self, chat_session_id: str) -> None:
+        stale: list[ACPChatConn] = []
+        with self._lock:
+            for key, e in list(self._entries.items()):
+                if e.chat_id != chat_session_id:
+                    continue
+                if e.conn is not None:
+                    stale.append(e.conn)
+                    e.conn = None
+                del self._entries[key]
+        _close_conns(stale)
+
+    def close_all(self) -> None:
+        with self._lock:
+            stale = [e.conn for e in self._entries.values() if e.conn is not None]
+            for e in self._entries.values():
+                e.conn = None
+            self._entries.clear()
+        _close_conns(stale)
+
+    def _take_idle_locked(self, now: float) -> list[ACPChatConn]:
+        stale: list[ACPChatConn] = []
+        for key, e in list(self._entries.items()):
+            if now - e.last_used <= self.idle_timeout:
+                continue
+            if e.conn is not None:
+                stale.append(e.conn)
+                e.conn = None
+            del self._entries[key]
+            log.info(
+                "chat acp pool evicted idle connection provider=%s chat=%s",
+                e.provider,
+                e.chat_id[:8],
+            )
+        return stale
+
+    def _take_oldest_locked(self) -> list[ACPChatConn]:
+        if not self._entries:
+            return []
+        oldest_key = min(self._entries, key=lambda k: self._entries[k].last_used)
+        e = self._entries.pop(oldest_key)
+        log.info(
+            "chat acp pool evicted oldest connection provider=%s chat=%s",
+            e.provider,
+            e.chat_id[:8],
+        )
+        if e.conn is None:
+            return []
+        conn = e.conn
+        e.conn = None
+        return [conn]
+
+
+def pool_key(provider: str, chat_session_id: str, agent_id: str, work_dir: str) -> str:
+    return "\x00".join([provider, chat_session_id, agent_id, work_dir])
+
+
+def agent_id_from_task(task: Any) -> str:
+    agent = getattr(task, "agent", None) or {}
+    if isinstance(agent, dict):
+        return str(agent.get("id") or "")
+    return ""
+
+
+def skip_cursor_chat_session_resume(provider: str, chat_session_id: str) -> bool:
+    """Cursor must not session/load a completed chat ACP session."""
+    return provider == "cursor" and bool(str(chat_session_id or "").strip())
+
+
+def _should_evict(result: ACPPromptResult) -> bool:
+    return result.status in ("aborted", "cancelled", "timeout", "idle_watchdog")
+
+
+def _close_conns(conns: list[ACPChatConn]) -> None:
+    for c in conns:
+        try:
+            c.close()
+        except Exception:
+            pass

aicortexpy/cli.py

@@ -0,0 +1,133 @@
+"""CLI entry: python -m aicortexpy <command>."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+from . import __version__
+from .capabilities import format_table
+from .config import load_config
+from .daemon import Daemon
+from .platform_info import platform_label
+from .process import log_path, spawn_background, status_text, stop_daemon
+from .sandbox import describe_default_strategy
+
+
+def _setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="python -m aicortexpy",
+        description="AICortex Python local agent runtime daemon (MVP)",
+    )
+    p.add_argument("--version", action="version", version=f"aicortexpy {__version__}")
+    p.add_argument("--profile", default="", help="CLI profile name (default profile if empty)")
+    p.add_argument("-v", "--verbose", action="store_true")
+
+    sub = p.add_subparsers(dest="command", required=True)
+
+    start = sub.add_parser("start", help="Start daemon in background")
+    start.add_argument(
+        "--foreground",
+        action="store_true",
+        help="Run in the current terminal instead of detaching",
+    )
+
+    sub.add_parser("run", help="Run daemon in foreground (used by start / service)")
+    sub.add_parser("stop", help="Stop the running daemon")
+    sub.add_parser("status", help="Show daemon status")
+    sub.add_parser("restart", help="Restart daemon")
+    sub.add_parser(
+        "capabilities",
+        help="List Go daemon capabilities vs Python implementation status",
+    )
+    sub.add_parser(
+        "sandbox-info",
+        help="Show host OS sandbox strategy (Win/macOS/Linux)",
+    )
+
+    du = sub.add_parser(
+        "disk-usage",
+        help="Scan workspaces root disk usage (read-only)",
+    )
+    du.add_argument("--json", action="store_true", help="Emit JSON report")
+    du.add_argument("--top", type=int, default=20, help="Show top N task dirs")
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    _setup_logging(args.verbose)
+
+    if args.command == "capabilities":
+        print(format_table())
+        return 0
+
+    if args.command == "sandbox-info":
+        print(f"platform: {platform_label()}")
+        print(describe_default_strategy())
+        return 0
+
+    if args.command == "disk-usage":
+        import json
+
+        from .diskusage import format_report_table, report_to_dict, scan_disk_usage
+
+        cfg = load_config(args.profile, require_agents=False)
+        report = scan_disk_usage(cfg.workspaces_root)
+        if args.json:
+            print(json.dumps(report_to_dict(report), ensure_ascii=False, indent=2))
+        else:
+            print(format_report_table(report, top=args.top))
+        return 0
+
+    if args.command == "status":
+        cfg = load_config(args.profile, require_agents=False)
+        print(status_text(cfg))
+        return 0
+
+    if args.command == "stop":
+        cfg = load_config(args.profile, require_agents=False)
+        print(stop_daemon(cfg))
+        return 0
+
+    if args.command == "restart":
+        cfg = load_config(args.profile, require_agents=False)
+        print(stop_daemon(cfg))
+        cfg = load_config(args.profile, require_agents=True)
+        pid = spawn_background(cfg)
+        print(f"restarted pid={pid}")
+        print(f"logs: {log_path(cfg)}")
+        return 0
+
+    if args.command == "start":
+        cfg = load_config(args.profile, require_agents=True)
+        if args.foreground:
+            return Daemon(cfg).run()
+        pid = spawn_background(cfg)
+        print(f"started pid={pid}")
+        print(f"health: http://127.0.0.1:{cfg.health_port}/health")
+        print(f"logs: {log_path(cfg)}")
+        return 0
+
+    if args.command == "run":
+        cfg = load_config(args.profile, require_agents=True)
+        return Daemon(cfg).run()
+
+    parser.print_help()
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())