aicortexpy 0.2.0__tar.gz → 0.2.1__tar.gz

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/PKG-INFO

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

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/__init__.py

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

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/acp_client.py

@@ -236,7 +236,9 @@ class ACPClient:
             if self.on_message:
                 self.on_message(
                     {
-                        "type": "tool-use",
+                        # Server/UI wire format uses underscores (Go daemon maps
+                        # internal "tool-use" → "tool_use" before ReportTaskMessages).
+                        "type": "tool_use",
                         "tool": tool_name,
                         "call_id": call_id,
                         "input": raw_input,
@@ -271,8 +273,18 @@ class ACPClient:
         output = str(data.get("rawOutput") or data.get("output") or "")
         if not output:
             output = _extract_tool_call_text(content)
+        tool_name = ""
+        if pending is not None:
+            tool_name = pending.tool_name or ""
         if self.on_message:
-            self.on_message({"type": "tool-result", "call_id": call_id, "output": output})
+            self.on_message(
+                {
+                    "type": "tool_result",
+                    "tool": tool_name or "tool",
+                    "call_id": call_id,
+                    "output": output,
+                }
+            )
 
     def _emit_deferred_tool_use(self, pending: _PendingTool | None, call_id: str, data: dict) -> None:
         if pending is not None and pending.emitted:
@@ -300,7 +312,12 @@ class ACPClient:
             inp = {}
         if self.on_message:
             self.on_message(
-                {"type": "tool-use", "tool": tool_name, "call_id": call_id, "input": inp}
+                {
+                    "type": "tool_use",
+                    "tool": tool_name,
+                    "call_id": call_id,
+                    "input": inp,
+                }
             )
 
     def _track_tool(self, call_id: str, p: _PendingTool) -> None:

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/acp_conn.py

@@ -226,9 +226,9 @@ class _BaseACPConn:
             typ = msg.get("type")
             if typ == "text":
                 output_parts.append(str(msg.get("content") or ""))
-            elif typ == "tool-use":
+            elif typ in ("tool_use", "tool-use"):
                 in_flight_tools["n"] += 1
-            elif typ == "tool-result":
+            elif typ in ("tool_result", "tool-result"):
                 in_flight_tools["n"] = max(0, in_flight_tools["n"] - 1)
             messages.append(msg)
             if on_message:

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/attachments.py

@@ -61,7 +61,9 @@ def materialize_attachments(
         if not att_id:
             continue
         try:
-            body, header_name = client.fetch_attachment_bytes(att_id)
+            body, header_name = client.fetch_attachment_bytes(
+                att_id, task.workspace_id
+            )
         except Exception as e:
             log.warning("fetch attachment failed id=%s: %s", att_id, e)
             continue

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/cli.py

@@ -22,8 +22,10 @@ from .commands import (
     project_cmd,
     repo_cmd,
     runtime_cmd,
+    setup_cmd,
     skill_cmd,
     squad_cmd,
+    update_cmd,
     version_cmd,
     workspace_cmd,
 )
@@ -41,12 +43,31 @@ _LEGACY_DAEMON = {
 }
 
 
-def _setup_logging(verbose: bool = False) -> None:
-    level = logging.DEBUG if verbose else logging.WARNING
+def _setup_logging(
+    verbose: bool = False,
+    *,
+    log_level: str = "",
+    daemon_mode: bool = False,
+) -> None:
+    """Configure root logging.
+
+    - CLI one-shots default to WARNING (quiet).
+    - Daemon run defaults to INFO (useful in python-daemon.log).
+    - `-v` or `--log-level DEBUG` enables DEBUG.
+    """
+    if log_level:
+        level = getattr(logging, log_level.upper(), logging.INFO)
+    elif verbose:
+        level = logging.DEBUG
+    elif daemon_mode:
+        level = logging.INFO
+    else:
+        level = logging.WARNING
     logging.basicConfig(
         level=level,
         format="%(asctime)s %(levelname)s %(name)s: %(message)s",
         datefmt="%H:%M:%S",
+        force=True,
     )
 
 
@@ -80,6 +101,8 @@ def build_parser() -> argparse.ArgumentParser:
     config_cmd.add_parser(sub)
     daemon_cmd.add_parser(sub)
     runtime_cmd.add_parser(sub)
+    setup_cmd.add_parser(sub)
+    update_cmd.add_parser(sub)
     version_cmd.add_parser(sub)
     return p
 
@@ -100,8 +123,15 @@ def main(argv: list[str] | None = None) -> int:
     except SystemExit as e:
         return int(e.code) if isinstance(e.code, int) else 1
 
-    _setup_logging(getattr(ns, "verbose", False))
     cmd = ns.command
+    _setup_logging(
+        getattr(ns, "verbose", False),
+        log_level=str(getattr(ns, "log_level", "") or ""),
+        daemon_mode=(
+            cmd == "daemon"
+            and getattr(ns, "daemon_command", "") in {"start", "run", "restart"}
+        ),
+    )
 
     handlers = {
         "issue": issue_cmd.run,
@@ -123,6 +153,8 @@ def main(argv: list[str] | None = None) -> int:
         "version": version_cmd.run,
         "login": auth_cmd.run_login,
         "auth": auth_cmd.run_auth,
+        "setup": setup_cmd.run,
+        "update": update_cmd.run,
     }
     handler = handlers.get(cmd)
     if not handler:

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/client.py

@@ -422,10 +422,17 @@ class DaemonClient:
         data = self.get(f"/api/daemon/workspaces/{workspace_id}/repos")
         return data if isinstance(data, dict) else {}
 
-    def fetch_attachment_bytes(self, attachment_id: str) -> tuple[bytes, str]:
+    def fetch_attachment_bytes(
+        self, attachment_id: str, workspace_id: str = ""
+    ) -> tuple[bytes, str]:
         path = f"/api/daemon/attachments/{attachment_id}/bytes"
         url = self.base_url + path
-        req = urllib.request.Request(url, headers=self._headers(), method="GET")
+        headers = self._headers()
+        wid = (workspace_id or "").strip()
+        if wid:
+            # PAT/JWT daemon auth has no workspace in context; server requires it.
+            headers["X-Workspace-ID"] = wid
+        req = urllib.request.Request(url, headers=headers, method="GET")
         try:
             with urllib.request.urlopen(req, timeout=self.timeout, context=self._ctx) as resp:
                 body = resp.read(MAX_ATTACHMENT_BYTES + 1)

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/commands/agent_cmd.py

@@ -4,12 +4,16 @@ from __future__ import annotations
 
 import argparse
 import sys
+from pathlib import Path
 
 from ..cli_context import require_client
 from ..id_resolve import list_agents, resolve_by_prefix
 from ..output import print_json, str_val
 from ..platform_client import PlatformError, q
 
+_AVATAR_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+_AVATAR_MAX = 5 << 20  # 5 MiB
+
 
 def add_parser(sub: argparse._SubParsersAction) -> None:
     p = sub.add_parser("agent", help="Work with agents")
@@ -37,6 +41,10 @@ def add_parser(sub: argparse._SubParsersAction) -> None:
     tasks = asub.add_parser("tasks", help="List agent tasks")
     tasks.add_argument("agent_id")
     tasks.add_argument("--output", choices=["json", "table"], default="json")
+    avatar = asub.add_parser("avatar", help="Upload an avatar image for an agent")
+    avatar.add_argument("agent_id")
+    avatar.add_argument("--file", required=True, help="Path to avatar image (.png/.jpg/.gif/.webp)")
+    avatar.add_argument("--output", choices=["json", "table"], default="json")
     skills = asub.add_parser("skills", help="Agent skills")
     ssub = skills.add_subparsers(dest="agent_skills_command", required=True)
     sl = ssub.add_parser("list")
@@ -95,6 +103,35 @@ def run(ns: argparse.Namespace) -> int:
         if ns.agent_command == "tasks":
             print_json(client.get(f"/api/agents/{_aid(client, ns.agent_id)}/tasks"))
             return 0
+        if ns.agent_command == "avatar":
+            path = Path(ns.file)
+            if not path.is_file():
+                print(f"file not found: {path}", file=sys.stderr)
+                return 1
+            ext = path.suffix.lower()
+            if ext not in _AVATAR_EXTS:
+                print(
+                    f"unsupported file format {ext!r}: must be .png, .jpg, .jpeg, .gif, or .webp",
+                    file=sys.stderr,
+                )
+                return 1
+            data = path.read_bytes()
+            if len(data) > _AVATAR_MAX:
+                print(f"file too large: {len(data)} bytes (max 5MB)", file=sys.stderr)
+                return 1
+            aid = _aid(client, ns.agent_id)
+            client.get(f"/api/agents/{aid}")  # existence check
+            att_id, url = client.upload_file_with_url(data, str(path))
+            if not url:
+                print("upload succeeded but no url returned", file=sys.stderr)
+                return 1
+            client.put(f"/api/agents/{aid}", {"avatar_url": url})
+            result = {"id": att_id, "agent_id": aid, "avatar_url": url}
+            if ns.output == "json":
+                print_json(result)
+            else:
+                print(f"{att_id}\t{aid}\t{url}")
+            return 0
         if ns.agent_command == "skills":
             aid = _aid(client, ns.agent_id)
             if ns.agent_skills_command == "list":

aicortexpy-0.2.1/aicortexpy/commands/auth_cmd.py

@@ -0,0 +1,167 @@
+"""login / auth commands."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import sys
+
+from .. import __version__
+from ..cli_context import profile_of, resolve_server_url, resolve_token, save_cli_config
+from ..config import load_cli_config
+from ..oauth_login import browser_login
+from ..platform_client import PlatformClient, PlatformError
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    login = sub.add_parser(
+        "login",
+        help="Authenticate (browser OAuth, or --token for PAT)",
+    )
+    login.add_argument(
+        "--token",
+        nargs="?",
+        const="",
+        default=None,
+        help="PAT (mul_...); pass --token alone to prompt; omit for browser OAuth",
+    )
+    login.add_argument(
+        "--callback-host",
+        default="",
+        help="Host the OAuth callback URL points at (auto-detected when empty)",
+    )
+
+    auth = sub.add_parser("auth", help="Authenticate aicortexpy with AICortex")
+    asub = auth.add_subparsers(dest="auth_command", required=True)
+    asub.add_parser("status", help="Show authentication status")
+    asub.add_parser("logout", help="Remove stored token")
+
+
+def _resolve_app_url(ns: argparse.Namespace) -> str:
+    env = (
+        os.environ.get("AICORTEX_APP_URL", "").strip()
+        or os.environ.get("FRONTEND_ORIGIN", "").strip()
+    )
+    if env:
+        return env.rstrip("/")
+    cfg = load_cli_config(profile_of(ns))
+    return (cfg.app_url or "").rstrip("/")
+
+
+def _save_token_and_workspaces(ns: argparse.Namespace, token: str, server: str) -> int:
+    client = PlatformClient(server, token, "", version=__version__)
+    try:
+        me = client.get("/api/me")
+    except PlatformError as e:
+        print(f"invalid token: {e}", file=sys.stderr)
+        return 1
+    profile = profile_of(ns)
+    cfg = load_cli_config(profile)
+    cfg.token = token
+    cfg.server_url = server
+    if not cfg.app_url:
+        cfg.app_url = _resolve_app_url(ns)
+    cfg.workspace_id = ""
+    try:
+        workspaces = client.get("/api/workspaces")
+        if isinstance(workspaces, list) and workspaces:
+            cfg.workspace_id = str(workspaces[0].get("id") or "")
+            print(f"\nFound {len(workspaces)} workspace(s):", file=sys.stderr)
+            for ws in workspaces:
+                print(f"  - {ws.get('name')} ({ws.get('id')})", file=sys.stderr)
+        else:
+            print("\nNo workspaces found.", file=sys.stderr)
+            app = cfg.app_url or _resolve_app_url(ns)
+            if app:
+                print(
+                    f"Create a workspace in the web dashboard: {app}/workspaces/new",
+                    file=sys.stderr,
+                )
+    except PlatformError:
+        pass
+    save_cli_config(cfg, profile)
+    name = (me or {}).get("name") if isinstance(me, dict) else ""
+    email = (me or {}).get("email") if isinstance(me, dict) else ""
+    print(f"Authenticated as {name} ({email})\nToken saved to config.", file=sys.stderr)
+    print("\n→ Run 'aicortex daemon start' to start your local agent runtime.", file=sys.stderr)
+    return 0
+
+
+def run_login(ns: argparse.Namespace) -> int:
+    # --token present (even empty const) → PAT path; otherwise browser OAuth.
+    if ns.token is not None:
+        token = ns.token
+        if token == "":
+            token = getpass.getpass("Enter your personal access token: ").strip()
+        token = (token or "").strip()
+        if not token.startswith("mul_"):
+            print("invalid token format: must start with mul_", file=sys.stderr)
+            return 1
+        return _save_token_and_workspaces(ns, token, resolve_server_url(ns))
+
+    server = resolve_server_url(ns)
+    app = _resolve_app_url(ns)
+    profile = profile_of(ns)
+    try:
+        browser_login(
+            server_url=server,
+            app_url=app,
+            profile=profile,
+            callback_host_flag=getattr(ns, "callback_host", "") or "",
+        )
+    except SystemExit as e:
+        if e.args and isinstance(e.args[0], str):
+            print(e.args[0], file=sys.stderr)
+        return 1 if e.code not in (0, None) else 0
+
+    # Pick default workspace after OAuth saved the token.
+    cfg = load_cli_config(profile)
+    token = cfg.token
+    if not token:
+        return 1
+    client = PlatformClient(server, token, "", version=__version__)
+    try:
+        workspaces = client.get("/api/workspaces")
+        if isinstance(workspaces, list) and workspaces:
+            cfg.workspace_id = str(workspaces[0].get("id") or "")
+            save_cli_config(cfg, profile)
+            print(f"\nFound {len(workspaces)} workspace(s):", file=sys.stderr)
+            for ws in workspaces:
+                print(f"  - {ws.get('name')} ({ws.get('id')})", file=sys.stderr)
+    except PlatformError:
+        pass
+    print("\n→ Run 'aicortex daemon start' to start your local agent runtime.", file=sys.stderr)
+    return 0
+
+
+def run_auth(ns: argparse.Namespace) -> int:
+    profile = profile_of(ns)
+    if ns.auth_command == "logout":
+        cfg = load_cli_config(profile)
+        cfg.token = ""
+        save_cli_config(cfg, profile)
+        print("Logged out.", file=sys.stderr)
+        return 0
+    token = resolve_token(ns)
+    server = resolve_server_url(ns)
+    if not token:
+        print(
+            "Not authenticated. Run 'aicortexpy login' (browser) or 'aicortexpy login --token mul_...'.",
+            file=sys.stderr,
+        )
+        return 0
+    client = PlatformClient(server, token, "", version=__version__)
+    try:
+        me = client.get("/api/me")
+    except PlatformError as e:
+        print(
+            f"Token is invalid or expired: {e}\nRun 'aicortexpy login' to re-authenticate.",
+            file=sys.stderr,
+        )
+        return 0
+    prefix = token[:12] + "..." if len(token) > 12 else token
+    name = (me or {}).get("name") if isinstance(me, dict) else ""
+    email = (me or {}).get("email") if isinstance(me, dict) else ""
+    print(f"Server:  {server}\nUser:    {name} ({email})\nToken:   {prefix}", file=sys.stderr)
+    return 0

{aicortexpy-0.2.0 → aicortexpy-0.2.1}/aicortexpy/commands/autopilot_cmd.py

@@ -6,7 +6,12 @@ import argparse
 import sys
 
 from ..cli_context import require_client
-from ..id_resolve import list_agents, resolve_autopilot, resolve_by_prefix
+from ..id_resolve import (
+    list_agents,
+    resolve_autopilot,
+    resolve_autopilot_trigger,
+    resolve_by_prefix,
+)
 from ..output import print_json
 from ..platform_client import PlatformError, q
 
@@ -36,7 +41,7 @@ def add_parser(sub: argparse._SubParsersAction) -> None:
     update.add_argument("--output", choices=["json", "table"], default="json")
     delete = asub.add_parser("delete")
     delete.add_argument("autopilot_id")
-    trigger = asub.add_parser("trigger")
+    trigger = asub.add_parser("trigger", help="Manually trigger an autopilot once")
     trigger.add_argument("autopilot_id")
     trigger.add_argument("--output", choices=["json", "table"], default="json")
     runs = asub.add_parser("runs")
@@ -44,6 +49,37 @@ def add_parser(sub: argparse._SubParsersAction) -> None:
     runs.add_argument("--limit", type=int, default=50)
     runs.add_argument("--output", choices=["json", "table"], default="json")
 
+    tadd = asub.add_parser("trigger-add", help="Add a schedule trigger to an autopilot")
+    tadd.add_argument("autopilot_id")
+    tadd.add_argument("--cron", required=True, help="Cron expression (required)")
+    tadd.add_argument("--timezone", default="", help="IANA timezone (default UTC)")
+    tadd.add_argument("--label", default="", help="Optional human-readable label")
+    tadd.add_argument("--output", choices=["json", "table"], default="json")
+
+    tupd = asub.add_parser("trigger-update", help="Update an existing trigger")
+    tupd.add_argument("autopilot_id")
+    tupd.add_argument("trigger_id")
+    tupd.add_argument("--enabled", default=None, choices=["true", "false", "1", "0", "yes", "no"])
+    tupd.add_argument("--cron", default=None)
+    tupd.add_argument("--timezone", default=None)
+    tupd.add_argument("--label", default=None)
+    tupd.add_argument("--output", choices=["json", "table"], default="json")
+
+    tdel = asub.add_parser("trigger-delete", help="Delete a trigger")
+    tdel.add_argument("autopilot_id")
+    tdel.add_argument("trigger_id")
+
+
+def _parse_bool(raw: str | None) -> bool | None:
+    if raw is None:
+        return None
+    v = raw.strip().lower()
+    if v in {"true", "1", "yes", "y", "on"}:
+        return True
+    if v in {"false", "0", "no", "n", "off"}:
+        return False
+    raise SystemExit(f"invalid boolean value: {raw!r}")
+
 
 def run(ns: argparse.Namespace) -> int:
     client = require_client(ns)
@@ -94,6 +130,54 @@ def run(ns: argparse.Namespace) -> int:
             aid = resolve_autopilot(client, ns.autopilot_id)
             print_json(client.get(f"/api/autopilots/{aid}/runs{q({'limit': ns.limit})}"))
             return 0
+        if ns.autopilot_command == "trigger-add":
+            aid = resolve_autopilot(client, ns.autopilot_id)
+            body: dict = {
+                "kind": "schedule",
+                "cron_expression": ns.cron,
+            }
+            if ns.timezone:
+                body["timezone"] = ns.timezone
+            if ns.label:
+                body["label"] = ns.label
+            result = client.post(f"/api/autopilots/{aid}/triggers", body)
+            if ns.output == "json":
+                print_json(result)
+            else:
+                rid = (result or {}).get("id") if isinstance(result, dict) else ""
+                print(f"Trigger created: {rid}")
+            return 0
+        if ns.autopilot_command == "trigger-update":
+            aid = resolve_autopilot(client, ns.autopilot_id)
+            tid = resolve_autopilot_trigger(client, aid, ns.trigger_id)
+            body = {}
+            enabled = _parse_bool(ns.enabled)
+            if enabled is not None:
+                body["enabled"] = enabled
+            if ns.cron is not None:
+                body["cron_expression"] = ns.cron
+            if ns.timezone is not None:
+                body["timezone"] = ns.timezone
+            if ns.label is not None:
+                body["label"] = ns.label
+            if not body:
+                print(
+                    "no fields to update; use --enabled, --cron, --timezone, or --label",
+                    file=sys.stderr,
+                )
+                return 1
+            result = client.patch(f"/api/autopilots/{aid}/triggers/{tid}", body)
+            if ns.output == "json":
+                print_json(result)
+            else:
+                print(f"Trigger updated: {tid}")
+            return 0
+        if ns.autopilot_command == "trigger-delete":
+            aid = resolve_autopilot(client, ns.autopilot_id)
+            tid = resolve_autopilot_trigger(client, aid, ns.trigger_id)
+            client.delete(f"/api/autopilots/{aid}/triggers/{tid}")
+            print(f"Trigger {tid} deleted.", file=sys.stderr)
+            return 0
     except PlatformError as e:
         print(str(e), file=sys.stderr)
         return 1