aicortexpy 0.2.2__tar.gz → 0.2.4__tar.gz

{aicortexpy-0.2.2/aicortexpy.egg-info → aicortexpy-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aicortexpy
-Version: 0.2.2
+Version: 0.2.4
 Summary: AICortex Python CLI and local agent runtime daemon (Go CLI compatible)
 Author: AICortex
 License: Apache-2.0

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/__init__.py

@@ -1,3 +1,3 @@
 """AICortex Python CLI + local agent runtime daemon."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/acp_conn.py

@@ -23,7 +23,11 @@ from .acp_client import (
     kiro_tool_name,
     resolve_resumed_session_id,
 )
-from .acp_errors import ACPProviderErrorSniffer, promote_acp_result_on_provider_error
+from .acp_errors import (
+    ACPProviderErrorSniffer,
+    enrich_kiro_acp_error,
+    promote_acp_result_on_provider_error,
+)
 from .procutil import kill_process_tree, popen_kwargs_for_killable_group
 from .security import SecurityPolicy, build_cursor_acp_global_flags, default_security_policy
 
@@ -33,9 +37,20 @@ HANDSHAKE_TIMEOUT = 120.0
 PROMPT_TIMEOUT = 20 * 60.0
 STDOUT_MAX_LINE = 10 * 1024 * 1024  # match Go scanner max token
 
+# UI / agent form may send these; ACP session/set_model rejects them (e.g. Cursor -32602).
+_ACP_MODEL_SENTINELS = frozenset({"", "auto", "default", "none"})
+
 MessageCB = Callable[[dict[str, Any]], None]
 
 
+def normalize_acp_model(model: str | None) -> str:
+    """Return a concrete model id for ACP, or '' to keep the agent default."""
+    m = (model or "").strip()
+    if m.lower() in _ACP_MODEL_SENTINELS:
+        return ""
+    return m
+
+
 @dataclass
 class ACPPromptResult:
     status: str
@@ -73,15 +88,16 @@ def kiro_acp_supported(executable: str) -> bool:
 
 
 def _acp_help_ok(executable: str, *, extra_before: list[str]) -> bool:
+    from .procutil import run_no_window
+
     path = shutil.which(executable) or executable
     args = [path, *extra_before]
     try:
-        proc = subprocess.run(
+        proc = run_no_window(
             args,
             capture_output=True,
             timeout=5,
             check=False,
-            **_hide_window(),
         )
         return proc.returncode == 0
     except (OSError, subprocess.TimeoutExpired):
@@ -89,11 +105,9 @@ def _acp_help_ok(executable: str, *, extra_before: list[str]) -> bool:
 
 
 def _hide_window() -> dict:
-    if sys.platform != "win32":
-        return {}
-    startup = subprocess.STARTUPINFO()
-    startup.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-    return {"startupinfo": startup}
+    from .procutil import popen_kwargs_hidden_console
+
+    return popen_kwargs_hidden_console()
 
 
 def choose_cursor_invocation(executable: str, args: list[str]) -> tuple[str, list[str]]:
@@ -344,6 +358,8 @@ class _BaseACPConn:
         status, error = promote_acp_result_on_provider_error(
             status, error, output, self._sniffer
         )
+        if self.provider == "kiro" and status == "failed" and error:
+            error = enrich_kiro_acp_error(error)
 
         usage = None
         with client._usage_lock:
@@ -528,26 +544,43 @@ class _BaseACPConn:
                 raise RuntimeError(f"{self.provider} acp session/new returned no session ID")
         self._session_id = session_id
         self._client.session_id = session_id
-        self._model = model
+        # UI may send sentinel "auto"/"default"; ACP session/set_model rejects those.
+        effective_model = normalize_acp_model(model)
+        self._model = effective_model
         log.info("%s acp session ready session_id=%s", self.provider, session_id)
-        if not model:
+        if not effective_model:
+            if (model or "").strip():
+                log.info(
+                    "%s acp skipping set_model for sentinel model=%r",
+                    self.provider,
+                    model,
+                )
             return
         try:
             if self.model_via_config_option:
                 self._client.request(
                     "session/set_config_option",
-                    {"sessionId": session_id, "configId": "model", "value": model},
+                    {
+                        "sessionId": session_id,
+                        "configId": "model",
+                        "value": effective_model,
+                    },
                     timeout=handshake_timeout,
                 )
             else:
                 self._client.request(
                     "session/set_model",
-                    {"sessionId": session_id, "modelId": model},
+                    {"sessionId": session_id, "modelId": effective_model},
                     timeout=handshake_timeout,
                 )
         except Exception as e:
             if self.soft_set_model:
-                log.debug("%s acp set_model skipped: %s", self.provider, e)
+                log.warning(
+                    "%s acp set_model soft-failed model=%r: %s (continuing with agent default)",
+                    self.provider,
+                    effective_model,
+                    e,
+                )
                 return
             self.close()
             raise RuntimeError(f"{self.provider} acp set model failed: {e}") from e
@@ -556,6 +589,8 @@ class _BaseACPConn:
 class CursorACPConn(_BaseACPConn):
     provider = "cursor"
     require_set_model = True
+    # Prefer pooled chat over hard-failing on an unknown model id.
+    soft_set_model = True
 
     @classmethod
     def open(

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/acp_errors.py

@@ -19,6 +19,10 @@ _ACP_TERMINAL_ERROR_RE = re.compile(
 _ACP_AGENT_OUTPUT_TERMINAL_RE = re.compile(r"API call failed after \d+ retr(?:y|ies)")
 _ACP_MAX_ERROR_LINES = 8
 
+_KIRO_EXPLICIT_AUTH_RE = re.compile(r"no token|not logged in", re.IGNORECASE)
+_KIRO_DISPATCH_RE = re.compile(r"dispatch failure", re.IGNORECASE)
+_KIRO_LOGIN_HINT_RE = re.compile(r"kiro-cli login", re.IGNORECASE)
+
 
 class ACPProviderErrorSniffer:
     def __init__(self, provider: str) -> None:
@@ -105,3 +109,22 @@ def promote_acp_result_on_provider_error(
         if msg:
             return "failed", msg
     return final_status, final_error
+
+
+def enrich_kiro_acp_error(error: str) -> str:
+    """Append login/retry hints from Kiro ACP error text alone (no extra CLI probes)."""
+    if not error or _KIRO_LOGIN_HINT_RE.search(error):
+        return error
+    if _KIRO_EXPLICIT_AUTH_RE.search(error):
+        return (
+            "kiro-cli is not logged in. Run `kiro-cli login`, then retry. "
+            f"({error})"
+        )
+    if _KIRO_DISPATCH_RE.search(error):
+        # Kiro often surfaces logout/network problems only as "dispatch failure".
+        return (
+            f"{error} "
+            "(common causes: kiro-cli not logged in - run `kiro-cli login`; "
+            "or transient AWS Q network error - retry)"
+        )
+    return error

aicortexpy-0.2.4/aicortexpy/app_workdir.py

@@ -0,0 +1,72 @@
+"""Pinned app template / instance workdirs (port of Go daemon/app_workdir.go)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from .client import Task
+
+log = logging.getLogger("aicortexpy.app_workdir")
+
+_DEFAULT_SEED = b"<!DOCTYPE html><html><body><h1>App</h1></body></html>\n"
+
+
+def app_uses_pinned_workdir(task: Task) -> bool:
+    return bool(task.app_id.strip()) and task.app_mode in ("edit", "run")
+
+
+def prepare_app_workdir(workspaces_root: Path, task: Task) -> Path:
+    """Create/reuse app template or instance dir; seed index.html from task.app_html."""
+    ws = (task.workspace_id or "").strip()
+    app_id = task.app_id.strip()
+    if not ws or not app_id:
+        raise ValueError("missing app workdir identity")
+
+    base = workspaces_root / ws / "apps" / app_id
+    mode = task.app_mode
+    if mode == "edit":
+        directory = base / "template"
+    elif mode == "run":
+        if task.app_workdir_mode == "shared":
+            directory = base / "instances" / "shared"
+        else:
+            user_id = task.app_user_id.strip() or "anonymous"
+            directory = base / "instances" / "users" / user_id
+    else:
+        raise ValueError(f"unknown app mode {mode!r}")
+
+    directory.mkdir(parents=True, exist_ok=True)
+    index_path = directory / "index.html"
+    seed_text = task.app_html.strip()
+    seed = seed_text.encode("utf-8") if seed_text else _DEFAULT_SEED
+    need_write = (not index_path.is_file()) or index_path.stat().st_size == 0
+    if not need_write and seed_text:
+        # Server AppHTML is authoritative at task start; refresh stale disk
+        # copies (e.g. first-run default seed) so complete_task won't clobber DB.
+        try:
+            existing = index_path.read_text(encoding="utf-8")
+        except OSError:
+            existing = ""
+        if existing.strip() != seed_text:
+            need_write = True
+    if need_write:
+        index_path.write_bytes(seed)
+        log.info("seeded app index.html at %s mode=%s", index_path, mode)
+    return directory
+
+
+def read_app_index_html(work_dir: str | Path) -> str:
+    path = Path(work_dir) / "index.html"
+    return path.read_text(encoding="utf-8")
+
+
+def is_app_workdir_path(path: Path) -> bool:
+    """True when path sits under .../apps/<id>/(template|instances)/..."""
+    parts = path.resolve().parts
+    try:
+        i = parts.index("apps")
+    except ValueError:
+        return False
+    return i + 1 < len(parts)

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/artifact_ws.py

@@ -110,10 +110,14 @@ class ArtifactBrowser:
                 st = child.stat()
             except OSError:
                 continue
+            child_rel = (
+                f"{rel.rstrip('/')}/{child.name}".lstrip("/") if rel else child.name
+            )
+            # Protocol (Go ArtifactListEntry) expects `path`, not `rel_path`.
             entries.append(
                 {
                     "name": child.name,
-                    "rel_path": f"{rel.rstrip('/')}/{child.name}".lstrip("/") if rel else child.name,
+                    "path": child_rel,
                     "is_dir": child.is_dir(),
                     "size": st.st_size if child.is_file() else 0,
                     "mtime": int(st.st_mtime),

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/artifacts.py

@@ -64,4 +64,10 @@ def report_issue_artifacts(
     try:
         report(items)
     except Exception as e:
+        # Issue preview is feature-flagged off by default (404 "not found").
+        # Chat/app workdirs often have index.html that is not an issue artifact.
+        status = getattr(e, "status", None)
+        if status in (400, 404):
+            log.debug("report artifacts skipped: %s", e)
+            return
         log.warning("report artifacts failed: %s", e)

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/auto_commit.py

@@ -27,7 +27,9 @@ EXCLUDE = [
 
 
 def _git(cwd: Path, *args: str) -> tuple[int, str, str]:
-    proc = subprocess.run(
+    from .procutil import run_no_window
+
+    proc = run_no_window(
         ["git", *args],
         cwd=str(cwd),
         capture_output=True,

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/cli.py

@@ -63,11 +63,21 @@ def _setup_logging(
         level = logging.INFO
     else:
         level = logging.WARNING
+    # Windows consoles are often GBK; force UTF-8 so agent names like 小政 log cleanly.
+    for stream in (sys.stdout, sys.stderr):
+        reconf = getattr(stream, "reconfigure", None)
+        if callable(reconf):
+            try:
+                reconf(encoding="utf-8", errors="replace")
+            except Exception:
+                pass
     logging.basicConfig(
         level=level,
         format="%(asctime)s %(levelname)s %(name)s: %(message)s",
         datefmt="%H:%M:%S",
         force=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
 

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import ssl
 import urllib.error
 import urllib.request
@@ -12,6 +13,7 @@ from typing import Any
 from .platform_info import host_os
 
 MAX_ATTACHMENT_BYTES = 100 << 20
+log = logging.getLogger("aicortexpy")
 
 
 class APIError(Exception):
@@ -31,6 +33,29 @@ def is_not_found(err: Exception, needle: str) -> bool:
     )
 
 
+def is_connection_reset(err: BaseException) -> bool:
+    """True when the peer closed the TCP socket mid-request (e.g. WinError 10054)."""
+    if isinstance(err, ConnectionResetError):
+        return True
+    if isinstance(err, BrokenPipeError):
+        return True
+    if isinstance(err, OSError):
+        # Windows: 10054 (reset), 10053 (local abort); POSIX: ECONNRESET=104 / macOS 54
+        if getattr(err, "winerror", None) in (10054, 10053):
+            return True
+        if getattr(err, "errno", None) in (104, 54):
+            return True
+    # urllib wraps the socket error in URLError.reason
+    reason = getattr(err, "reason", None)
+    if isinstance(reason, BaseException) and reason is not err:
+        return is_connection_reset(reason)
+    cause = getattr(err, "__cause__", None) or getattr(err, "__context__", None)
+    if isinstance(cause, BaseException) and cause is not err:
+        return is_connection_reset(cause)
+    msg = str(err)
+    return "10054" in msg or "10053" in msg
+
+
 @dataclass
 class Task:
     raw: dict[str, Any]
@@ -177,6 +202,38 @@ class Task:
     def session_kind(self) -> str:
         return self._s("session_kind")
 
+    @property
+    def app_id(self) -> str:
+        return self._s("app_id")
+
+    @property
+    def app_mode(self) -> str:
+        return self._s("app_mode")
+
+    @property
+    def app_name(self) -> str:
+        return self._s("app_name")
+
+    @property
+    def app_description(self) -> str:
+        return self._s("app_description")
+
+    @property
+    def app_spec(self) -> str:
+        return self._s("app_spec")
+
+    @property
+    def app_workdir_mode(self) -> str:
+        return self._s("app_workdir_mode")
+
+    @property
+    def app_html(self) -> str:
+        return self._s("app_html")
+
+    @property
+    def app_user_id(self) -> str:
+        return self._s("app_user_id")
+
     @property
     def squad_id(self) -> str:
         return self._s("squad_id")
@@ -238,6 +295,9 @@ class DaemonClient:
             "Authorization": f"Bearer {self.token}",
             "X-Client-Platform": "daemon",
             "X-Client-OS": host_os(),
+            # Avoid Windows urllib keep-alive reuse of half-closed sockets
+            # (WinError 10054 mid-claim after the server already dispatched).
+            "Connection": "close",
         }
         if self.version:
             headers["X-Client-Version"] = self.version
@@ -293,7 +353,32 @@ class DaemonClient:
         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", {})
+        path = f"/api/daemon/runtimes/{runtime_id}/tasks/claim"
+        try:
+            data = self.post(path, {})
+        except Exception as e:
+            # Server may have already marked the task dispatched before the
+            # response was reset. Retry once: ClaimTaskForRuntime redelivers
+            # unstarted dispatched rows. Only fail orphans if retry also dies
+            # — otherwise we kill healthy work that just lost the HTTP body.
+            if not is_connection_reset(e):
+                raise
+            log.warning(
+                "claim %s connection reset; retrying once for redelivery",
+                runtime_id[:8],
+            )
+            try:
+                data = self.post(path, {})
+            except Exception as e2:
+                if is_connection_reset(e2):
+                    n = self.fail_orphaned_dispatched(runtime_id, reason=str(e2))
+                    if n:
+                        log.warning(
+                            "claim %s retry reset; failed %d orphaned dispatched task(s)",
+                            runtime_id[:8],
+                            n,
+                        )
+                raise
         if not isinstance(data, dict):
             return None
         task = data.get("task")
@@ -301,6 +386,33 @@ class DaemonClient:
             return None
         return Task(task)
 
+    def list_pending_tasks(self, runtime_id: str) -> list[dict[str, Any]]:
+        data = self.get(f"/api/daemon/runtimes/{runtime_id}/tasks/pending")
+        return [x for x in data if isinstance(x, dict)] if isinstance(data, list) else []
+
+    def fail_orphaned_dispatched(self, runtime_id: str, *, reason: str = "") -> int:
+        """Fail dispatched tasks left behind when a claim response was lost."""
+        try:
+            pending = self.list_pending_tasks(runtime_id)
+        except Exception:
+            return 0
+        failed = 0
+        msg = "claim response lost (connection reset); please retry"
+        if reason:
+            msg = f"{msg}: {reason}"
+        for row in pending:
+            if str(row.get("status") or "") != "dispatched":
+                continue
+            tid = str(row.get("id") or "")
+            if not tid:
+                continue
+            try:
+                self.fail_task(tid, msg, failure_reason="runtime_recovery")
+                failed += 1
+            except Exception:
+                continue
+        return failed
+
     def start_task(self, task_id: str) -> None:
         self.post(f"/api/daemon/tasks/{task_id}/start", {})
 
@@ -318,6 +430,7 @@ class DaemonClient:
         work_dir: str = "",
         session_id: str = "",
         branch_name: str = "",
+        app_html: str = "",
     ) -> None:
         body: dict[str, Any] = {"output": output}
         if work_dir:
@@ -326,6 +439,8 @@ class DaemonClient:
             body["session_id"] = session_id
         if branch_name:
             body["branch_name"] = branch_name
+        if app_html.strip():
+            body["app_html"] = app_html
         self.post(f"/api/daemon/tasks/{task_id}/complete", body)
 
     def fail_task(

{aicortexpy-0.2.2 → aicortexpy-0.2.4}/aicortexpy/commands/agent_cmd.py

@@ -28,6 +28,7 @@ def add_parser(sub: argparse._SubParsersAction) -> None:
     create.add_argument("--name", required=True)
     create.add_argument("--instructions", default="")
     create.add_argument("--from-template", default="")
+    create.add_argument("--runtime-id", default="", help="Runtime id to execute this agent")
     create.add_argument("--output", choices=["json", "table"], default="json")
     update = asub.add_parser("update", help="Update agent")
     update.add_argument("agent_id")
@@ -79,9 +80,13 @@ def run(ns: argparse.Namespace) -> int:
         if ns.agent_command == "create":
             if ns.from_template:
                 body = {"name": ns.name, "template": ns.from_template, "workspace_id": client.workspace_id}
+                if ns.runtime_id:
+                    body["runtime_id"] = ns.runtime_id
                 print_json(client.post("/api/agents/from-template", body))
             else:
                 body = {"name": ns.name, "workspace_id": client.workspace_id}
+                if ns.runtime_id:
+                    body["runtime_id"] = ns.runtime_id
                 if ns.instructions:
                     body["instructions"] = ns.instructions
                 print_json(client.post("/api/agents", body))