aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/terminal.py

@@ -0,0 +1,147 @@
+"""Remote terminal sessions over wakeup WS (MVP; opt-in via aicortex_TERMINAL_PTY).
+
+Uses a pipe-based shell session (not full ConPTY/unix pty) so Windows/macOS/Linux
+share one code path. Good enough for command I/O; not a true interactive TTY.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import subprocess
+import threading
+from typing import Any, Callable
+
+from .procutil import kill_process_tree, popen_kwargs_for_killable_group
+
+log = logging.getLogger("aicortexpy.terminal")
+
+MAX_SESSIONS = 10
+SendFn = Callable[[str, dict[str, Any]], None]
+
+
+def terminal_pty_enabled() -> bool:
+    raw = (os.environ.get("aicortex_TERMINAL_PTY") or "").strip().lower()
+    return raw in ("1", "true", "yes", "on")
+
+
+class TerminalManager:
+    def __init__(self, send: SendFn | None = None):
+        self._send = send
+        self._mu = threading.Lock()
+        self._sessions: dict[str, dict[str, Any]] = {}
+
+    def set_send(self, send: SendFn) -> None:
+        self._send = send
+
+    def handle_open(self, payload: dict[str, Any]) -> None:
+        if not terminal_pty_enabled():
+            self._error(payload, "terminal pty disabled (set aicortex_TERMINAL_PTY=true)")
+            return
+        sid = str(payload.get("session_id") or payload.get("id") or "").strip()
+        if not sid:
+            self._error(payload, "session id required")
+            return
+        with self._mu:
+            if len(self._sessions) >= MAX_SESSIONS:
+                self._error(payload, "too many terminal sessions")
+                return
+            if sid in self._sessions:
+                self._error(payload, "session already open")
+                return
+        cwd = str(payload.get("cwd") or os.getcwd())
+        shell = os.environ.get("COMSPEC") if os.name == "nt" else (os.environ.get("SHELL") or "/bin/bash")
+        try:
+            proc = subprocess.Popen(
+                [shell],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=cwd if os.path.isdir(cwd) else None,
+                text=False,
+                bufsize=0,
+                **popen_kwargs_for_killable_group(),
+            )
+        except OSError as e:
+            self._error(payload, str(e))
+            return
+        with self._mu:
+            self._sessions[sid] = {"proc": proc}
+        threading.Thread(
+            target=self._reader, args=(sid, proc), name=f"term-{sid[:8]}", daemon=True
+        ).start()
+        if self._send:
+            self._send("terminal:attached", {"session_id": sid})
+
+    def handle_data(self, payload: dict[str, Any]) -> None:
+        sid = str(payload.get("session_id") or payload.get("id") or "").strip()
+        data_b64 = str(payload.get("data") or "")
+        with self._mu:
+            sess = self._sessions.get(sid)
+        if not sess:
+            return
+        proc: subprocess.Popen = sess["proc"]
+        try:
+            raw = base64.b64decode(data_b64) if data_b64 else b""
+            if proc.stdin and raw:
+                proc.stdin.write(raw)
+                proc.stdin.flush()
+        except OSError as e:
+            self._error(payload, str(e))
+
+    def handle_resize(self, payload: dict[str, Any]) -> None:
+        # Pipe-based MVP has no PTY size; acknowledge silently.
+        return
+
+    def handle_close(self, payload: dict[str, Any]) -> None:
+        sid = str(payload.get("session_id") or payload.get("id") or "").strip()
+        with self._mu:
+            sess = self._sessions.pop(sid, None)
+        if not sess:
+            return
+        proc: subprocess.Popen = sess["proc"]
+        try:
+            kill_process_tree(proc.pid)
+        except Exception:
+            pass
+
+    def handle_attach(self, payload: dict[str, Any]) -> None:
+        sid = str(payload.get("session_id") or payload.get("id") or "").strip()
+        with self._mu:
+            exists = sid in self._sessions
+        if exists and self._send:
+            self._send("terminal:attached", {"session_id": sid})
+        elif not exists:
+            self._error(payload, "session not found")
+
+    def handle_detach(self, payload: dict[str, Any]) -> None:
+        return
+
+    def _reader(self, sid: str, proc: subprocess.Popen) -> None:
+        assert proc.stdout is not None
+        try:
+            while True:
+                chunk = proc.stdout.read(4096)
+                if not chunk:
+                    break
+                if self._send:
+                    self._send(
+                        "terminal:data",
+                        {
+                            "session_id": sid,
+                            "data": base64.b64encode(chunk).decode("ascii"),
+                        },
+                    )
+        except Exception as e:
+            log.debug("terminal reader %s: %s", sid, e)
+        finally:
+            with self._mu:
+                self._sessions.pop(sid, None)
+            if self._send:
+                self._send("terminal:close", {"session_id": sid})
+
+    def _error(self, payload: dict[str, Any], message: str) -> None:
+        sid = str(payload.get("session_id") or payload.get("id") or "")
+        if self._send:
+            self._send("terminal:error", {"session_id": sid, "error": message})

aicortexpy/tunnel.py

@@ -0,0 +1,82 @@
+"""Loopback HTTP tunnel proxy (Go daemon/tunnel/proxy.go)."""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import threading
+import urllib.error
+import urllib.request
+from typing import Any, Callable
+
+log = logging.getLogger("aicortexpy.tunnel")
+
+MAX_BODY = 2 * 1024 * 1024
+PROXY_TIMEOUT = 30.0
+_HOP_BY_HOP = {
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+}
+
+SendFn = Callable[[str, dict[str, Any]], None]
+
+
+class TunnelProxy:
+    def __init__(self, send: SendFn | None = None):
+        self._send = send
+
+    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="tunnel-req", daemon=True
+        ).start()
+
+    def _handle(self, payload: dict[str, Any]) -> None:
+        req_id = str(payload.get("request_id") or payload.get("requestId") or "")
+        resp: dict[str, Any] = {"request_id": req_id}
+        try:
+            port = int(payload.get("port") or 0)
+            if port < 1 or port > 65535:
+                raise ValueError(f"invalid port {port}")
+            method = str(payload.get("method") or "GET").upper()
+            path = str(payload.get("path") or "/")
+            if not path.startswith("/"):
+                path = "/" + path
+            body_b64 = str(payload.get("body") or "")
+            body = base64.b64decode(body_b64) if body_b64 else b""
+            if len(body) > MAX_BODY:
+                raise ValueError("request body too large")
+            headers = payload.get("headers") if isinstance(payload.get("headers"), dict) else {}
+            url = f"http://127.0.0.1:{port}{path}"
+            req = urllib.request.Request(url, data=body or None, method=method)
+            for k, v in headers.items():
+                if str(k).lower() in _HOP_BY_HOP:
+                    continue
+                req.add_header(str(k), str(v))
+            with urllib.request.urlopen(req, timeout=PROXY_TIMEOUT) as http_resp:
+                raw = http_resp.read(MAX_BODY + 1)
+                if len(raw) > MAX_BODY:
+                    raise ValueError("response body too large")
+                resp["status"] = http_resp.status
+                resp_headers: dict[str, str] = {}
+                for k, v in http_resp.headers.items():
+                    if k.lower() in _HOP_BY_HOP:
+                        continue
+                    resp_headers[k] = v
+                resp["headers"] = resp_headers
+                if raw:
+                    resp["body"] = base64.b64encode(raw).decode("ascii")
+        except Exception as e:
+            resp["error"] = str(e)
+            log.debug("tunnel request failed id=%s: %s", req_id, e)
+        if self._send:
+            self._send("tunnel:response", resp)

aicortexpy/wakeup.py

@@ -0,0 +1,222 @@
+"""WebSocket task-wakeup + tunnel/artifact/terminal mux (poll fallback remains)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from typing import Any, Callable
+from urllib.parse import urlencode, urlparse, urlunparse
+
+from .artifact_ws import ArtifactBrowser
+from .platform_info import host_os
+from .terminal import TerminalManager, terminal_pty_enabled
+from .tunnel import TunnelProxy
+
+log = logging.getLogger("aicortexpy.wakeup")
+
+EVENT_TASK_AVAILABLE = "daemon:task_available"
+EVENT_HEARTBEAT = "daemon:heartbeat"
+
+
+def task_wakeup_url(base_url: str, runtime_ids: list[str]) -> str:
+    u = urlparse(base_url.strip())
+    scheme = u.scheme.lower()
+    if scheme == "http":
+        scheme = "ws"
+    elif scheme == "https":
+        scheme = "wss"
+    elif scheme not in ("ws", "wss"):
+        raise ValueError(f"server URL must be http(s)/ws(s), got {u.scheme!r}")
+    path = (u.path or "").rstrip("/") + "/api/daemon/ws"
+    ids = sorted({r for r in runtime_ids if r})
+    query = urlencode({"runtime_ids": ",".join(ids)})
+    return urlunparse((scheme, u.netloc, path, "", query, ""))
+
+
+class WakeupHub:
+    """Owns the daemon WS connection write mux + sideband handlers."""
+
+    def __init__(self) -> None:
+        self._ws = None
+        self._write_mu = threading.Lock()
+        self.tunnel = TunnelProxy(self.send)
+        self.artifacts = ArtifactBrowser(self.send)
+        self.terminal = TerminalManager(self.send)
+
+    def bind_ws(self, ws: Any) -> None:
+        self._ws = ws
+        self.tunnel.set_send(self.send)
+        self.artifacts.set_send(self.send)
+        self.terminal.set_send(self.send)
+
+    def clear_ws(self) -> None:
+        self._ws = None
+
+    def send(self, typ: str, payload: dict[str, Any]) -> None:
+        ws = self._ws
+        if ws is None:
+            return
+        msg = {"type": typ, "payload": payload}
+        raw = json.dumps(msg, ensure_ascii=False)
+        with self._write_mu:
+            try:
+                ws.send(raw)
+            except Exception as e:
+                log.debug("wakeup send failed type=%s: %s", typ, e)
+
+    def dispatch(self, msg: dict[str, Any], wake: threading.Event) -> None:
+        typ = str(msg.get("type") or "")
+        payload = msg.get("payload")
+        if isinstance(payload, str):
+            try:
+                payload = json.loads(payload)
+            except json.JSONDecodeError:
+                payload = {}
+        if not isinstance(payload, dict):
+            payload = msg if typ and typ != EVENT_TASK_AVAILABLE else {}
+
+        if typ == EVENT_TASK_AVAILABLE:
+            log.debug("task wakeup received")
+            wake.set()
+            return
+        if typ == "tunnel:request":
+            self.tunnel.handle_request(payload)
+            return
+        if typ == "artifact:request":
+            self.artifacts.handle_request(payload)
+            return
+        if typ.startswith("terminal:"):
+            handlers = {
+                "terminal:open": self.terminal.handle_open,
+                "terminal:attach": self.terminal.handle_attach,
+                "terminal:data": self.terminal.handle_data,
+                "terminal:resize": self.terminal.handle_resize,
+                "terminal:detach": self.terminal.handle_detach,
+                "terminal:close": self.terminal.handle_close,
+            }
+            fn = handlers.get(typ)
+            if fn:
+                fn(payload)
+            return
+
+
+def run_wakeup_loop(
+    *,
+    stop: threading.Event,
+    wake: threading.Event,
+    get_runtime_ids: Callable[[], list[str]],
+    base_url: str,
+    token: str,
+    version: str = "",
+    hub: WakeupHub | None = None,
+) -> None:
+    """Connect to daemon WS; set `wake` when task_available arrives."""
+    try:
+        import websocket  # type: ignore[import-untyped]
+    except ImportError:
+        log.warning(
+            "websocket-client not installed; wakeup WS disabled "
+            "(pip install websocket-client). Polling still works."
+        )
+        stop.wait()
+        return
+
+    hub = hub or WakeupHub()
+    backoff = 1.0
+
+    while not stop.is_set():
+        ids = get_runtime_ids()
+        if not ids:
+            stop.wait(5.0)
+            continue
+        id_key = tuple(sorted(ids))
+        try:
+            url = task_wakeup_url(base_url, ids)
+        except ValueError as e:
+            log.warning("wakeup URL invalid: %s", e)
+            stop.wait(30.0)
+            continue
+
+        headers = [
+            f"Authorization: Bearer {token}",
+            "X-Client-Platform: daemon",
+            f"X-Client-OS: {host_os()}",
+        ]
+        if version:
+            headers.append(f"X-Client-Version: {version}")
+
+        closed = threading.Event()
+
+        def on_message(_ws: object, message: str | bytes) -> None:
+            try:
+                raw = message.decode("utf-8") if isinstance(message, bytes) else message
+                msg = json.loads(raw)
+            except Exception:
+                return
+            if not isinstance(msg, dict):
+                return
+            hub.dispatch(msg, wake)
+
+        def on_error(_ws: object, error: object) -> None:
+            log.debug("wakeup ws error: %s", error)
+
+        def on_close(_ws: object, *_args: object) -> None:
+            hub.clear_ws()
+            closed.set()
+
+        def on_open(ws: object) -> None:
+            nonlocal backoff
+            backoff = 1.0
+            hub.bind_ws(ws)
+            log.info(
+                "task wakeup websocket connected runtimes=%s terminal_pty=%s",
+                len(ids),
+                terminal_pty_enabled(),
+            )
+            wake.set()
+            # Periodic WS heartbeat (best-effort; server may ignore).
+            def _hb() -> None:
+                while not stop.is_set() and not closed.is_set():
+                    hub.send(EVENT_HEARTBEAT, {"ts": int(time.time())})
+                    stop.wait(25.0)
+
+            threading.Thread(target=_hb, name="wakeup-hb", daemon=True).start()
+
+        ws_app = websocket.WebSocketApp(
+            url,
+            header=headers,
+            on_message=on_message,
+            on_error=on_error,
+            on_close=on_close,
+            on_open=on_open,
+        )
+
+        def _run() -> None:
+            ws_app.run_forever(ping_interval=30, ping_timeout=10)
+
+        t = threading.Thread(target=_run, name="wakeup-ws", daemon=True)
+        t.start()
+
+        while not stop.is_set() and not closed.is_set():
+            if tuple(sorted(get_runtime_ids())) != id_key:
+                try:
+                    ws_app.close()
+                except Exception:
+                    pass
+                break
+            stop.wait(1.0)
+
+        try:
+            ws_app.close()
+        except Exception:
+            pass
+        hub.clear_ws()
+        t.join(timeout=5.0)
+
+        if stop.is_set():
+            return
+        log.debug("wakeup ws reconnect in %.1fs", backoff)
+        stop.wait(backoff)
+        backoff = min(backoff * 2, 30.0)

aicortexpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.2
+Name: aicortexpy
+Version: 0.1.0
+Summary: AICortex Python local agent runtime daemon (no Docker)
+Author: AICortex
+License: Apache-2.0
+Project-URL: Homepage, https://gitee.com/seacozz2007/aicortex
+Project-URL: Repository, https://gitee.com/seacozz2007/aicortex
+Project-URL: Issues, https://gitee.com/seacozz2007/aicortex/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: websocket-client>=1.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+
+# aicortexpy（Python daemon）
+
+用已批准的 `python.exe` 跑本地 agent runtime（跨 Windows / macOS / Linux），**无需 Docker**。
+
+| | 名称 |
+|--|--|
+| PyPI | `aicortexpy`（`aicortex` 与已有包 `ai-cortex` 过近被拒） |
+| 模块 | `aicortexpy`（不能叫 `aicortex`：本仓库目录也叫 `aicortex`，在父目录执行会撞 PEP 420 命名空间包） |
+| 调用 | `python -m aicortexpy`（不注册 console script，避免与 Go CLI `aicortex` 抢 PATH） |
+
+```powershell
+pip install aicortexpy
+python -m aicortexpy --help
+```
+
+## 安装
+
+### 从 PyPI
+
+```powershell
+pip install -U aicortexpy
+```
+
+### 从源码（本仓库）
+
+```powershell
+cd python-daemon
+pip install -e .
+pip install -e ".[dev]"   # 含 build / twine
+```
+
+## 运行
+
+```powershell
+# 方式 A：经 Go aicortex CLI（推荐；需已 pip 安装本包）
+$env:AICORTEX_DAEMON_BACKEND = "python"
+aicortex daemon start
+aicortex daemon status
+aicortex daemon stop
+
+# 方式 B：直接启动
+python -m aicortexpy start --foreground
+python -m aicortexpy capabilities
+python -m aicortexpy --version
+```
+
+需要 `~/.aicortex/config.json`（token + server_url）以及 PATH 上的 agent CLI。
+
+Health 默认端口 **19514**（与 Go / `aicortex daemon status` 一致）。**不要**与 Go daemon 同时跑在同一端口。
+
+## 发布到 PyPI（对齐 aicorkit / aicortex-bridge）
+
+在 `python-daemon/` 目录：
+
+```powershell
+python -m pip install -U build twine
+python -m build
+python -m twine upload dist/*
+```
+
+版本号改 `pyproject.toml` 的 `version` 与 `aicortexpy/__init__.py` 的 `__version__`（保持一致），再重新 build / upload。
+
+## 已对齐能力（相对 Go daemon）
+
+- 注册/心跳/wakeup/claim/cancel、agentEnv、prior_work_dir 复用
+- Claude（stream-json + **MCP `--mcp-config`**）、Codex（+ semantic inactivity）
+- Cursor/Gemini/OpenCode/Copilot **stream-json/json 事件流**
+- Cursor/Kiro chat ACP 池；Kiro/Hermes/Kimi/Dsh ACP oneshot
+- OpenClaw / pi 启动参数；OpenClaw config **fail-closed**
+- Repo：**allowlist** + per-workspace bare + **worktree 锁** + co-authored hook
+- Design：**handoff zip** + **example seed**
+- Model list：**ACP discovery** + 60s cache
+- GC：`.gc_meta.json` + **active-root 保护**
+- Wakeup 侧带：**tunnel**、**artifact browse/chunk upload**、terminal（pipe MVP，需 `AICORTEX_DAEMON_TERMINAL_PTY=true`）
+
+**仍偏薄 / partial**：真正的 ConPTY/unix PTY（现为 pipe shell）、OS sandbox wrapper（bwrap/Seatbelt）、Go 式 auto-update（用 `pip install -U aicortexpy`）。
+
+## 环境变量（节选）
+
+| 变量 | 含义 |
+|------|------|
+| `AICORTEX_DAEMON_BACKEND` | `python` 时 `aicortex daemon start` 启 Python daemon |
+| `AICORTEX_DAEMON_HEALTH_PORT` | 默认 19514 |
+| `AICORTEX_DAEMON_TERMINAL_PTY` | `true` 启用远程终端（pipe MVP） |
+| `AICORTEX_AGENT_IDLE_WATCHDOG` | 无活动强停秒数（默认 300；`0` 关闭） |
+| `AICORTEX_CODEX_SEMANTIC_INACTIVITY_TIMEOUT` | Codex 无输出强停（默认 600；`0` 关闭） |
+| `AICORTEX_CODEX_MULTI_AGENT` | `1` 保留 Codex native multi_agent |
+| `AICORTEX_INJECT_TENCENT_DOCS` | `1` 注入完整 tencent-docs 包 |
+| `AICORTEX_GC_*` | GC 开关与 TTL |

aicortexpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,58 @@
+aicortexpy/__init__.py,sha256=JLvtEW8nsZgV2d81Kd4lekdVD3AsBXgF8GH6ZHM6IF0,76
+aicortexpy/__main__.py,sha256=0JBt6BfnwPz39k7xe6r7RsoyW5_XlsefeixJPkuheW0,101
+aicortexpy/acp_client.py,sha256=-pf5QwvZbHUW7a7oKVVRohbDOvfKiOTC5wWhL58pCcY,20424
+aicortexpy/acp_conn.py,sha256=JVVByMD3leiIRbJRD_n8jpkbulMAiwfAbVZj9Tbytv0,28933
+aicortexpy/acp_errors.py,sha256=3kJwwHvk6H8EjVWOU0yj3Uc9rMVF3F05qqfSY5cnVt8,3796
+aicortexpy/agent_env.py,sha256=w54dZS-g5lZNWejnk2wS3UgP9eCdwktAlqm0YotmLU8,2519
+aicortexpy/artifact_ws.py,sha256=KZXSsq1MPiD5nUzTI27vEUoZSbjKLOslJ5HM8VpuzQ4,9385
+aicortexpy/artifacts.py,sha256=0Q-dMq3m_nK7rqpAIAsVTtPQ0TV0AztmSgT8gu3qkv8,1724
+aicortexpy/attachments.py,sha256=khowvPc2jMuDWzhbXTOOOTieiOVnSuoCeispAsE70WE,2547
+aicortexpy/auto_commit.py,sha256=s-Hk1Wk1npk4AaMov0PS4D4_QVDvpzi378Viuqdw86U,3006
+aicortexpy/capabilities.py,sha256=TC8xIYYWOyzg_OfiBJ2MmyK8wFCNnrJ75tOmPD__NEs,6055
+aicortexpy/chat_acp_pool.py,sha256=wYL986M-PJzEAaEKJ5IA19tzu72HuUDsWfEgoaVcvdk,10674
+aicortexpy/cli.py,sha256=W0qTKd7f3tu7Z3K6Exixki1TKS9P-i6njhicN8JxFIk,4315
+aicortexpy/client.py,sha256=7PbG6c-_o86JO7ar85XbP9Q6WcTJQKHZk45-IQICuws,14282
+aicortexpy/codex_config.py,sha256=TNusK1gD0Df9B5ErrSr22peOiZ8MUdLpj8kpc6SncRM,3559
+aicortexpy/config.py,sha256=l4jtSl6ircxk-95LzxZjZv7X8D5OP3W38e13p3vYGWE,10665
+aicortexpy/daemon.py,sha256=FHjVFwTGYtDNvFvsrZibEKA7TXwtMcGFFr8vFqCG388,25283
+aicortexpy/design_seed.py,sha256=GT-7YFoxdx7yBzHK9aV6p1KLmXHoMDhl5RNRjZXTsN8,1981
+aicortexpy/diskusage.py,sha256=lPTxRk6Wez4BRAQLeXlMF4BsLtkvEnKFx5_Iddhu71w,6712
+aicortexpy/execenv.py,sha256=ILnGTDEmtP-XgIIGiNGR6zSEuid9oIUYCq_TFYfC6jg,9639
+aicortexpy/gc.py,sha256=8h1KewYIzdL1NXVX4-WG0owt_P2iD3Lr3ilja-aPPkc,8754
+aicortexpy/handoff_bundle.py,sha256=2DNm4QyiRbVP-J1qbhknoep7Odio5Gyzwrq03BWIcdY,2205
+aicortexpy/health.py,sha256=7btOmCmbW22ZU2Yz7f8JZOQ3m8R7W1DpBnKblbmnTyI,6838
+aicortexpy/local_skills.py,sha256=J7E9ey_hSEnbACG-4b_gfOdLXP3RRyuXDcQ_Xfz1WA8,4968
+aicortexpy/models.py,sha256=4WLGvDc1apbf9SD0gddulgpNNH5lkRUssga1QYxpJN8,12498
+aicortexpy/openclaw_config.py,sha256=FxQlAHcspbRUUMHFrn_bdG8xrXqxl9yGYA-CCbYFnws,5229
+aicortexpy/pinned_workdir.py,sha256=6PHrFJ9YlSvnDEiqs6RSB7dgmKeizgHC9Un-eSADB3I,1689
+aicortexpy/platform_info.py,sha256=AlFztNUlZC4OclTSXjpGd_UwHb-87dQSj58NWObzKfc,1441
+aicortexpy/poisoned.py,sha256=6P6CTi7eTxiJD_709xfNgeO_2qA-A1bQ525P2MNhYEw,1400
+aicortexpy/process.py,sha256=TWX7h9Cp1_lOJ_m0C8EK6_dbcAVmqWFvKj9jrzyrgII,5055
+aicortexpy/procutil.py,sha256=_EftI5v9Yer7T5exd7bPIpLxR5x08tRvu_5C9Mn6gEQ,1596
+aicortexpy/prompt.py,sha256=1s5R7jLPY-n9zmTL1jfPPDDFflLeNymJf5S8WsQHVxM,10280
+aicortexpy/repo.py,sha256=tnNh96q2_UcV3yELOLDufTCkrg9gs81Vmq9WGl-Or6c,15513
+aicortexpy/runner.py,sha256=Aei1m5JUUYwpMP6yYN3xd4VPm5Z22XkP0o3gyB6nPPk,31268
+aicortexpy/runtime_config.py,sha256=W94jPYXP7A7v1-QT6Br_ixlKAB176Ior1RbxUm2YDCI,22725
+aicortexpy/sandbox.py,sha256=jVhByEcYxXcw7nEj2mTl6FyoU8cQ1TA9WxyAxmdtNiQ,9114
+aicortexpy/stream.py,sha256=T7XyYxIoPTdXBTxzP3DUVjPJqTM5KXDtvFy0F8mUXgI,17503
+aicortexpy/terminal.py,sha256=Ml3i0IFJu8ZjSU5S4q8tptV4jBFHdOr8Q0LLx6rV9nk,5405
+aicortexpy/tunnel.py,sha256=A4Va42KxdxSQuVZhNK5MU1N_DTzLOtOAlYweGXaHPEA,3010
+aicortexpy/wakeup.py,sha256=3Rqjs4fkSHw4c3R8Tikm6WZR8u6AfAIWoxsbpwDrB3U,7231
+aicortexpy/data/default_skills/agent-memory/SKILL.md,sha256=c1oEhINeduE8UV5T27RPBWfB0l65U1WoOpOgMu_EGfQ,2992
+aicortexpy/data/default_skills/aicorkit-atlassian/SKILL.md,sha256=J9axzhdu-G5O1Crr0488S79UKt4IHD82iY-PCQ-VEY8,4939
+aicortexpy/data/default_skills/aicorkit-graph/SKILL.md,sha256=d438JVjCCiX8V8hkAtQdz3uUfRREG1vuoXFWZvGeQp4,6011
+aicortexpy/data/default_skills/aicorkit-outlook/SKILL.md,sha256=rR8RyNbIx3eK0ktRvxB5Xj4JBnWsu5fY1vLeA3diF0U,3221
+aicortexpy/data/default_skills/aicorkit-wxmsg/SKILL.md,sha256=ku8sBuVyy3h4K6L5B5GZjnOEFnfBhZeYAvsSiJWxhWA,3563
+aicortexpy/data/default_skills/aicortex-basics/SKILL.md,sha256=1_9fhqvBVy5_Ml7LdVfXVmSiMERoOzCndN8wWbI52gA,385
+aicortexpy/data/default_skills/aicortex-bridge-cdp/SKILL.md,sha256=7cr078IzMq4nVmefok7DJ5YsjSKOI051fCH53sJWaso,4198
+aicortexpy/data/default_skills/aicortex-cli-ops/SKILL.md,sha256=YrFCxogq-rKPa8IY6PIv_Yk_qha6hN0SBbQ9HNYyZ_M,3333
+aicortexpy/data/default_skills/aicortex-graph/SKILL.md,sha256=oiFyZRijBYK-Nfw0Yl2sbYljwlsR7DvnUnn6QdkRtUA,1389
+aicortexpy/data/default_skills/graphify/SKILL.md,sha256=rRF9IZ2WGoAe6vpIena8eUpKRaKojElsjBexQndmHHE,4861
+aicortexpy/data/default_skills/question-form/SKILL.md,sha256=pucPRblzVLHxugONJ1p-e7qgFCS8XAUEiHTQ6nj9bVY,5680
+aicortexpy/data/default_skills/test-report-generator/SKILL.md,sha256=-Oe8UdgCZvbeb-2Rk14N9D60NULvJredWmb-HL-X0Qw,8705
+aicortexpy/data/default_skills/test-report-generator/scripts/generate_cases.py,sha256=hfwgujxS6d-FkaSwjEWIgsP2XFWsHglawtee9gwW8yw,5442
+aicortexpy/data/default_skills/test-report-generator/scripts/generate_report.py,sha256=AD4CONpoidzpZStSYZaHw16_3pijyeKWl8y0lqpyjVY,10102
+aicortexpy-0.1.0.dist-info/METADATA,sha256=W_ZFodUFIf7JfR0G3XXjwAubAO8v2ePPd1gf57El14k,3917
+aicortexpy-0.1.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+aicortexpy-0.1.0.dist-info/top_level.txt,sha256=5qT2YcsQBb-n7HvUk94dAgMOStEeRDJIlDFuEZ7Q5To,11
+aicortexpy-0.1.0.dist-info/RECORD,,

aicortexpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aicortexpy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aicortexpy