aicortexpy 0.2.2__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aicortexpy
-Version: 0.2.2
+Version: 0.2.3
 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.3}/aicortexpy/__init__.py

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

{aicortexpy-0.2.2 → aicortexpy-0.2.3}/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
 
@@ -73,15 +77,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 +94,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 +347,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:

{aicortexpy-0.2.2 → aicortexpy-0.2.3}/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.3/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.3}/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.3}/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.3}/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.3}/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.3}/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))

aicortexpy-0.2.3/aicortexpy/commands/graph_cmd.py

@@ -0,0 +1,204 @@
+"""graph / knowledge commands (aligned with Go `aicortex graph`)."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from ..cli_context import require_client
+from ..output import print_json
+from ..platform_client import PlatformError
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("graph", help="Workspace Knowledge search/write/ensure")
+    gsub = p.add_subparsers(dest="graph_command", required=True)
+
+    cols = gsub.add_parser("collections", help="List Knowledge collections bound to this Agent")
+    cols.add_argument("--agent-id", default="", help="Override AICORTEX_AGENT_ID")
+    cols.add_argument("--output", choices=["json", "table"], default="json")
+
+    ensure = gsub.add_parser(
+        "ensure",
+        help="Create a Knowledge collection if missing and bind it to this Agent",
+    )
+    ensure.add_argument("--slug", required=True, help="Collection slug, e.g. APP_DATA_<app_id>")
+    ensure.add_argument("--name", default="", help="Display name (defaults to slug)")
+    ensure.add_argument("--description", default="")
+    ensure.add_argument(
+        "--visibility",
+        default="workspace",
+        choices=["private", "workspace", "restricted", "global"],
+    )
+    ensure.add_argument("--agent-id", default="", help="Override AICORTEX_AGENT_ID")
+    ensure.add_argument("--output", choices=["json", "table"], default="json")
+
+    search = gsub.add_parser("search")
+    search.add_argument("query", nargs="?", default="")
+    search.add_argument("--q", default="", help="Query (alternative to positional)")
+    search.add_argument("--collection", "--collection-id", dest="collection", default="")
+    search.add_argument("--mode", default="auto")
+    search.add_argument("-n", type=int, default=10)
+    search.add_argument("--output", choices=["json", "table"], default="json")
+
+    walk = gsub.add_parser("walk")
+    walk.add_argument("query", nargs="?", default="")
+    walk.add_argument("--q", default="")
+    walk.add_argument("--collection", "--collection-id", dest="collection", default="")
+    walk.add_argument("-n", type=int, default=5)
+    walk.add_argument("--output", choices=["json", "table"], default="json")
+
+    fetch = gsub.add_parser("fetch")
+    fetch.add_argument("--chunk-ids", required=True, help="comma-separated")
+    fetch.add_argument("--output", choices=["json", "table"], default="json")
+
+    write = gsub.add_parser("write")
+    write.add_argument("--collection", "--collection-id", dest="collection", default="")
+    write.add_argument("--title", required=True)
+    write.add_argument("--body", default="")
+    write.add_argument("--body-file", default="")
+    write.add_argument("--content", default="", help="Alias for --body (legacy)")
+    write.add_argument("--agent-id", default="", help="Override AICORTEX_AGENT_ID for binding lookup")
+    write.add_argument("--output", choices=["json", "table"], default="json")
+
+
+def _agent_id(ns: argparse.Namespace) -> str:
+    return (
+        str(getattr(ns, "agent_id", "") or "").strip()
+        or os.environ.get("AICORTEX_AGENT_ID", "").strip()
+    )
+
+
+def _query(ns: argparse.Namespace) -> str:
+    return (str(getattr(ns, "query", "") or "").strip() or str(getattr(ns, "q", "") or "").strip())
+
+
+def _resolve_body(ns: argparse.Namespace) -> str:
+    body = str(getattr(ns, "body", "") or "").strip()
+    if body:
+        return body
+    content = str(getattr(ns, "content", "") or "").strip()
+    if content:
+        return content
+    path = str(getattr(ns, "body_file", "") or "").strip()
+    if path:
+        return Path(path).read_text(encoding="utf-8")
+    return ""
+
+
+def _load_bound_collections(client, agent_id: str) -> list[dict]:
+    if agent_id:
+        rows = client.get(f"/api/agents/{agent_id}/knowledge")
+    else:
+        rows = client.get("/api/knowledge/collections")
+    if not isinstance(rows, list):
+        return []
+    out = []
+    for c in rows:
+        if not isinstance(c, dict):
+            continue
+        # Skip Agent Memory collections (owner_agent_id set)
+        if str(c.get("owner_agent_id") or "").strip():
+            continue
+        out.append(c)
+    return out
+
+
+def _match_collection(cols: list[dict], key: str) -> dict:
+    key = (key or "").strip()
+    if not key:
+        if len(cols) == 1:
+            return cols[0]
+        if not cols:
+            raise ValueError(
+                "no bound Knowledge collections; run: aicortex graph ensure --slug <slug> --name <name>"
+            )
+        raise ValueError("--collection is required when more than one library is bound")
+    kl = key.lower()
+    for c in cols:
+        if str(c.get("id") or "") == key or str(c.get("slug") or "").lower() == kl:
+            return c
+    raise ValueError(
+        f'collection "{key}" is not bound to this Agent; '
+        f"run: aicortex graph ensure --slug {key} --name {key}"
+    )
+
+
+def run(ns: argparse.Namespace) -> int:
+    client = require_client(ns)
+    try:
+        if ns.graph_command == "collections":
+            cols = _load_bound_collections(client, _agent_id(ns))
+            rows = [{"id": c.get("id"), "slug": c.get("slug"), "name": c.get("name")} for c in cols]
+            print_json({"count": len(rows), "collections": rows})
+            return 0
+
+        if ns.graph_command == "ensure":
+            agent_id = _agent_id(ns)
+            if not agent_id:
+                raise ValueError(
+                    "AICORTEX_AGENT_ID is required (set automatically during agent runs)"
+                )
+            slug = str(ns.slug).strip()
+            name = str(ns.name or "").strip() or slug
+            body = {
+                "slug": slug,
+                "name": name,
+                "description": str(ns.description or ""),
+                "visibility": str(ns.visibility or "workspace"),
+            }
+            print_json(client.post(f"/api/agents/{agent_id}/knowledge/ensure", body))
+            return 0
+
+        if ns.graph_command == "search":
+            q = _query(ns)
+            if not q:
+                raise ValueError("query is required")
+            body: dict = {"query": q, "mode": ns.mode, "limit": ns.n}
+            if ns.collection:
+                body["collection"] = ns.collection
+            print_json(client.post("/api/knowledge/search", body))
+            return 0
+
+        if ns.graph_command == "walk":
+            q = _query(ns)
+            if not q:
+                raise ValueError("query is required")
+            body = {"query": q, "limit": ns.n}
+            if ns.collection:
+                body["collection"] = ns.collection
+            print_json(client.post("/api/knowledge/walk", body))
+            return 0
+
+        if ns.graph_command == "fetch":
+            ids = [x.strip() for x in ns.chunk_ids.split(",") if x.strip()]
+            if not ids:
+                raise ValueError("--chunk-ids is required")
+            print_json(client.post("/api/knowledge/fetch", {"chunk_ids": ids}))
+            return 0
+
+        if ns.graph_command == "write":
+            body_text = _resolve_body(ns)
+            if not body_text.strip():
+                raise ValueError("--body, --body-file, or --content is required")
+            cols = _load_bound_collections(client, _agent_id(ns))
+            col = _match_collection(cols, ns.collection)
+            print_json(
+                client.post(
+                    f"/api/knowledge/collections/{col['id']}/documents",
+                    {
+                        "title": ns.title,
+                        "body": body_text,
+                        "source_id": "aicortex-graph",
+                        "source_kind": "document",
+                        "origin": "aicortex",
+                    },
+                )
+            )
+            return 0
+    except (PlatformError, ValueError, OSError) as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    return 2

{aicortexpy-0.2.2 → aicortexpy-0.2.3}/aicortexpy/commands/memory_cmd.py

@@ -37,7 +37,7 @@ def run(ns: argparse.Namespace) -> int:
         if ns.memory_command in {"ensure", "show"}:
             print_json(client.get(f"/api/agents/{ns.agent_id}/memory"))
             return 0
-        body = {"title": ns.title, "content": ns.content, "append": ns.memory_command == "append"}
+        body = {"title": ns.title, "body": ns.content, "append": ns.memory_command == "append"}
         print_json(client.post(f"/api/knowledge/collections/{ns.collection_id}/documents", body))
         return 0
     except PlatformError as e:

{aicortexpy-0.2.2 → aicortexpy-0.2.3}/aicortexpy/config.py

@@ -332,9 +332,11 @@ def detect_agent_version(executable: str) -> str:
     import re
     import subprocess
 
+    from .procutil import run_no_window
+
     for args in ([executable, "--version"], [executable, "version"], [executable, "-V"]):
         try:
-            proc = subprocess.run(
+            proc = run_no_window(
                 args,
                 capture_output=True,
                 text=True,