forgexa-cli 1.13.1__tar.gz → 1.13.3__tar.gz

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.13.1
+Version: 1.13.3
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.13.1"
+__version__ = "1.13.3"

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/forgexa_cli/daemon.py

@@ -523,7 +523,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.13.1"
+DAEMON_VERSION = "1.13.3"
 
 
 def _detect_client_type() -> str:
@@ -555,6 +555,8 @@ _CLIENT_TYPE = _detect_client_type()
 # (Makefile, Tauri desktop app, `forgexa daemon start --detach`, etc.).
 # A StreamHandler is added only when stderr is a TTY (foreground mode)
 # so logs are visible on the terminal without duplication.
+# Set DAEMON_NO_CONSOLE_LOG=1 to suppress the stream handler even on a TTY
+# (used by `forgexa daemon start` foreground mode for clean UX).
 _log_dir = Path.home() / ".forgexa" / "daemon"
 _log_dir.mkdir(parents=True, exist_ok=True)
 DAEMON_LOG_PATH = _log_dir / "daemon.log"
@@ -566,7 +568,7 @@ _log_handlers: list[logging.Handler] = [
         backupCount=5,
     ),
 ]
-if sys.stderr.isatty():
+if sys.stderr.isatty() and not os.environ.get("DAEMON_NO_CONSOLE_LOG"):
     _log_handlers.append(logging.StreamHandler(sys.stderr))
 
 logging.basicConfig(
@@ -2792,8 +2794,11 @@ class ProcessManager:
                 msg_data = data.get("data") or {}
                 if isinstance(msg_data.get("content"), str) and msg_data["content"].strip():
                     has_result = True
+            elif ev_type == "assistant.message_start":
+                has_assistant_events = True
             elif ev_type == "assistant.message_delta":
                 has_meaningful_content = True
+                has_assistant_events = True
             # ── Generic / Claude "result" event ────────────────────────────
             elif ev_type == "result":
                 # Copilot result format: {"type":"result","exitCode":0,"usage":{...}}
@@ -2916,6 +2921,19 @@ class ProcessManager:
             or signals["has_meaningful_content"]
         )
 
+    @staticmethod
+    def _copilot_completed_without_result(stdout: str) -> bool:
+        """Detect Copilot runs that completed a turn but omitted the final result event."""
+        signals = ProcessManager._extract_output_signals(stdout)
+        return bool(
+            signals["has_turn_completed"]
+            and signals["has_assistant_events"]
+            and signals["has_meaningful_content"]
+            and not signals["has_result"]
+            and not signals["has_turn_failed"]
+            and not signals["error_messages"]
+        )
+
     @staticmethod
     def is_rate_limited(result: "TaskResult") -> bool:
         """Check if an agent failure warrants trying a different agent.
@@ -3930,6 +3948,7 @@ class ProcessManager:
             # Copilot always exits 0 on normal completion; check result.exitCode
             # from the JSONL "result" event for a true success signal.
             copilot_exit = self._extract_copilot_exit_code(stdout)
+            completed_without_result = self._copilot_completed_without_result(stdout)
             effective_rc = copilot_exit if copilot_exit is not None else returncode
 
             if effective_rc == 0 and returncode == 0:
@@ -3940,6 +3959,21 @@ class ProcessManager:
                     stderr=stderr[-10000:],
                     metrics=metrics,
                 )
+            elif copilot_exit is None and returncode != 0 and completed_without_result:
+                logger.warning(
+                    "Copilot exited with return code %s for task %s despite a completed assistant turn and no result event; recovering to validation path",
+                    returncode,
+                    task_id,
+                )
+                metrics["recovered_missing_result_event"] = True
+                metrics["recovered_process_returncode"] = returncode
+                return TaskResult(
+                    status="success",
+                    exit_code=0,
+                    stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                    stderr=stderr[-10000:],
+                    metrics=metrics,
+                )
             else:
                 return TaskResult(
                     status="failed",

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/forgexa_cli/main.py

@@ -16,7 +16,14 @@ Usage:
     forgexa workspace list
     forgexa project list --workspace <id>
     forgexa requirement list --project <id>
+    forgexa daemon start -d
     forgexa daemon status
+    forgexa daemon status --verbose
+    forgexa daemon logs -f
+    forgexa daemon logs -n 100 -f
+    forgexa daemon agents
+    forgexa daemon restart
+    forgexa daemon stop
     forgexa gates pending
     forgexa config show
     forgexa --help
@@ -247,6 +254,31 @@ def _is_virtualenv() -> bool:
     )
 
 
+def _is_pep668_environment() -> bool:
+    """Return True if the active Python is governed by PEP 668 (externally-managed).
+
+    Debian 12, Ubuntu 22.10+/24.04+, Fedora 38+ and other modern distros place
+    an EXTERNALLY-MANAGED marker in their stdlib directory.  pip refuses both
+    user-site and system-wide installs on these environments unless
+    --break-system-packages is explicitly passed — even ``pip install --user``
+    is blocked.  We detect the marker up-front so ``forgexa upgrade`` can add
+    the flag automatically rather than failing and asking the user to do it.
+    """
+    try:
+        import sysconfig as _sysconfig
+        stdlib = _sysconfig.get_path("stdlib")
+        if stdlib and (Path(stdlib) / "EXTERNALLY-MANAGED").exists():
+            return True
+    except Exception:
+        pass
+    try:
+        if (Path(sys.prefix) / "EXTERNALLY-MANAGED").exists():
+            return True
+    except Exception:
+        pass
+    return False
+
+
 def _is_user_site_install(dist_root: Path | None) -> bool:
     if dist_root is None:
         return False
@@ -355,6 +387,12 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
     command = [python, "-m", "pip", "install", "--upgrade"]
     if _is_user_site_install(dist_root) and not _is_virtualenv():
         command.append("--user")
+    if _is_pep668_environment():
+        # PEP 668 (Ubuntu 24.04+, Debian 12+, Fedora 38+, …) blocks pip
+        # installs — including --user — unless this flag is passed.  The
+        # original installation on this machine must have used it too, so
+        # adding it here is consistent and safe.
+        command.append("--break-system-packages")
     command.append(_package_spec_for_version(target_version))
     return UpgradePlan(
         installer="pip",
@@ -614,26 +652,185 @@ def _get_runtimes(include_all: bool = False) -> list[dict]:
     return runtimes if isinstance(runtimes, list) else []
 
 
+def _get_runtimes_silent(include_all: bool = False) -> list[dict]:
+    """Like _get_runtimes() but returns [] instead of sys.exit on any error."""
+    import urllib.request
+
+    path = "/runtimes" if include_all else "/runtimes/me"
+    url = f"{_api_url()}/api/v1{path}"
+    req = urllib.request.Request(url, headers=_headers(), method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            content = resp.read()
+            result = json.loads(content) if content else []
+            return result if isinstance(result, list) else []
+    except Exception:
+        return []
+
+
+def _scan_local_agents() -> list[dict]:
+    """Run a quick local agent discovery scan and return results as dicts.
+
+    Uses asyncio.run() so it works from synchronous CLI context.
+    Silently returns [] if anything goes wrong.
+    """
+    try:
+        import asyncio as _asyncio
+        from forgexa_cli.daemon import AgentDiscovery
+        discovered = _asyncio.run(AgentDiscovery().discover())
+        return [
+            {
+                "agent_id": a.agent_id,
+                "version": a.version,
+                "compatibility_level": a.compatibility_level,
+            }
+            for a in discovered
+        ]
+    except Exception:
+        return []
+
+
+def _show_discovered_agents(agents: list[dict], indent: str = "  ") -> None:
+    """Print a friendly list of discovered agents."""
+    if not agents:
+        print(f"{indent}No agent CLIs found.")
+        print(f"{indent}Install Claude Code, OpenAI Codex, Gemini CLI, Kimi Code, etc.")
+        return
+    print(f"{indent}{len(agents)} agent(s) discovered:")
+    for a in agents:
+        agent_id = a.get("agent_id", "?") if isinstance(a, dict) else str(a)
+        version  = a.get("version",  "")  if isinstance(a, dict) else ""
+        compat   = a.get("compatibility_level", "") if isinstance(a, dict) else ""
+        badge    = f"  [{compat}]" if compat else ""
+        ver_str  = f"  {version}" if version else ""
+        print(f"{indent}  ✓  {agent_id}{ver_str}{badge}")
+
+
+def _wait_and_show_daemon_agents(start_ts: float, timeout: float = 12.0) -> bool:
+    """Poll server until daemon registers (heartbeat >= start_ts), then show agents.
+
+    Returns True if registration was confirmed, False on timeout.
+    Silently skips if user is not authenticated.
+    """
+    if not _token():
+        return False
+
+    from datetime import datetime, timezone as _tz
+
+    deadline = time.time() + timeout
+    spin = ["-", "\\", "|", "/"]
+    i = 0
+
+    sys.stdout.write("  Registering with server...")
+    sys.stdout.flush()
+
+    while time.time() < deadline:
+        runtimes = _get_runtimes_silent()
+        for r in runtimes:
+            hb = r.get("last_heartbeat_at") or ""
+            if not hb:
+                continue
+            try:
+                dt = datetime.fromisoformat(hb.replace("Z", "+00:00"))
+                hb_ts = dt.timestamp()
+            except Exception:
+                continue
+            # Allow 5-second clock-skew window before the recorded start timestamp
+            if hb_ts >= (start_ts - 5):
+                sys.stdout.write("\r" + " " * 60 + "\r")
+                sys.stdout.flush()
+                agents = r.get("available_agents", [])
+                status = r.get("status", "")
+                runtime_short = r["id"][:8]
+                print(f"  Runtime ready  (id: {runtime_short}  status: {status})")
+                _show_discovered_agents(agents)
+                return True
+        spin_char = spin[i % 4]
+        sys.stdout.write(f"\r  {spin_char} Registering with server...")
+        sys.stdout.flush()
+        i += 1
+        time.sleep(0.4)
+
+    sys.stdout.write("\r" + " " * 60 + "\r")
+    sys.stdout.flush()
+    return False
+
+
 def cmd_daemon_status(args: argparse.Namespace) -> None:
+    # ── Local process status ─────────────────────────────────────────────────
+    local_pid = _find_running_daemon_pid()
+    log_path  = Path.home() / ".forgexa" / "daemon" / "daemon.log"
+    if local_pid:
+        print(f"Local daemon : running  (PID {local_pid})")
+    else:
+        print("Local daemon : not running")
+    print(f"Log file     : {log_path}")
+    print()
+
+    # ── Server-registered runtimes ───────────────────────────────────────────
     runtimes = _get_runtimes(include_all=getattr(args, "all", False))
     if not runtimes:
-        print("No daemons registered.")
+        print("No runtimes registered on server.")
+        if local_pid:
+            print("(Daemon is running locally but has not registered yet — wait a moment)")
         return
-    _print_table(
-        ["ID", "Daemon", "Device", "Status", "Active", "Max", "Heartbeat"],
-        [
-            [
-                r["id"][:8],
-                r["daemon_id"],
-                r.get("device_name", ""),
-                r["status"],
-                str(r.get("active_tasks", 0)),
-                str(r.get("max_concurrent_tasks", 0)),
-                r.get("last_heartbeat_at", "")[:19] if r.get("last_heartbeat_at") else "never",
+
+    verbose = getattr(args, "verbose", False)
+
+    if verbose:
+        # Expanded per-runtime block
+        for r in runtimes:
+            agents = r.get("available_agents", []) or []
+            hb = r.get("last_heartbeat_at", "")[:19] if r.get("last_heartbeat_at") else "never"
+            print(f"Runtime  : {r['id'][:8]}  ({r.get('status', '?')})")
+            print(f"  Daemon     : {r.get('daemon_id', '')}")
+            print(f"  Device     : {r.get('device_name', '')}")
+            print(f"  Active     : {r.get('active_tasks', 0)}/{r.get('max_concurrent_tasks', 0)} tasks")
+            print(f"  Heartbeat  : {hb}")
+            if agents:
+                print(f"  Agents     :")
+                for a in agents:
+                    if isinstance(a, dict):
+                        aid    = a.get("agent_id", "?")
+                        ver    = a.get("version", "")
+                        compat = a.get("compatibility_level", "")
+                    else:
+                        aid, ver, compat = str(a), "", ""
+                    badge   = f"  [{compat}]" if compat else ""
+                    ver_str = f"  {ver}" if ver else ""
+                    print(f"    ✓  {aid}{ver_str}{badge}")
+            else:
+                print(f"  Agents     : (none found)")
+            print()
+    else:
+        # Compact table with Agents column
+        def _fmt_agents(r: dict) -> str:
+            agents = r.get("available_agents", []) or []
+            if not agents:
+                return "(none)"
+            names = [
+                a.get("agent_id", "?") if isinstance(a, dict) else str(a)
+                for a in agents
             ]
-            for r in runtimes
-        ],
-    )
+            return ", ".join(names)
+
+        _print_table(
+            ["ID", "Daemon", "Device", "Status", "Agents", "Active/Max", "Heartbeat"],
+            [
+                [
+                    r["id"][:8],
+                    r.get("daemon_id", ""),
+                    r.get("device_name", ""),
+                    r["status"],
+                    _fmt_agents(r),
+                    f"{r.get('active_tasks', 0)}/{r.get('max_concurrent_tasks', 0)}",
+                    r.get("last_heartbeat_at", "")[:19] if r.get("last_heartbeat_at") else "never",
+                ]
+                for r in runtimes
+            ],
+        )
+        print()
+        print("Tip: use --verbose for per-agent detail")
 
 
 def cmd_daemon_stop(_args: argparse.Namespace) -> None:
@@ -657,49 +854,189 @@ def cmd_daemon_stop(_args: argparse.Namespace) -> None:
         print(f"Sent SIGTERM to daemon (PID {pid})")
 
 
+def cmd_daemon_restart(args: argparse.Namespace) -> None:
+    """Stop any running daemon, then start a fresh one in background."""
+    pid = _find_running_daemon_pid()
+    if pid is not None:
+        print(f"Stopping daemon (PID {pid})...")
+        try:
+            _stop_daemon_by_pid(pid)
+        except (PermissionError, RuntimeError) as exc:
+            print(f"Error stopping daemon: {exc}", file=sys.stderr)
+            sys.exit(1)
+        print("Daemon stopped.")
+        print()
+    else:
+        print("No daemon currently running — starting fresh.")
+        print()
+
+    # restart always runs in background so the shell is returned immediately
+    start_args = argparse.Namespace(
+        detach=True,
+        server_url=getattr(args, "server_url", None),
+    )
+    cmd_daemon_start(start_args)
+
+
 def cmd_daemon_start(args: argparse.Namespace) -> None:
     """Start the local daemon (agent runtime)."""
-    server_url = args.server_url or _api_url()
+    # Refuse to start a second instance
+    existing_pid = _find_running_daemon_pid()
+    if existing_pid is not None:
+        print(f"Daemon is already running (PID {existing_pid}).")
+        print("Use 'forgexa daemon restart' to restart it.")
+        sys.exit(1)
+
+    server_url = getattr(args, "server_url", None) or _api_url()
     os.environ["DAEMON_SERVER_URL"] = server_url
 
-    # Pass token if available
     token = _token()
     if token:
         os.environ.setdefault("DAEMON_API_TOKEN", token)
 
     if getattr(args, "detach", False):
-        # Background mode: spawn forgexa-daemon as detached subprocess.
-        # Redirect stderr to the canonical log file so logs are not lost.
+        # ── Background (detach) mode ─────────────────────────────────────────
         import subprocess as sp
 
         log_path = Path.home() / ".forgexa" / "daemon" / "daemon.log"
         log_path.parent.mkdir(parents=True, exist_ok=True)
 
+        start_ts = time.time()
         cmd = [sys.executable, "-m", "forgexa_cli.daemon"]
         with open(log_path, "a", encoding="utf-8") as log_fh:
             popen_kwargs: dict = dict(stdout=sp.DEVNULL, stderr=log_fh)
             if sys.platform == "win32":
-                # Windows: use creation flags to detach the process
                 popen_kwargs["creationflags"] = (
                     sp.CREATE_NEW_PROCESS_GROUP | sp.DETACHED_PROCESS
                 )
             else:
                 popen_kwargs["start_new_session"] = True
             proc = sp.Popen(cmd, **popen_kwargs)
+
         pid_file = Path.home() / ".forgexa-daemon.pid"
         pid_file.write_text(str(proc.pid))
-        print(f"Daemon started in background (PID {proc.pid})")
-        print(f"Server: {server_url}")
-        print(f"Logs:   {log_path}")
-        print(f"Stop with: forgexa daemon stop")
+
+        print(f"Daemon starting in background")
+        print(f"  PID    : {proc.pid}")
+        print(f"  Server : {server_url}")
+        print(f"  Logs   : {log_path}")
+        print()
+
+        detected = _wait_and_show_daemon_agents(start_ts)
+        if not detected:
+            if _token():
+                print("  (Agent registration not confirmed yet — check with: forgexa daemon status)")
+            else:
+                print("  (Not logged in — run 'forgexa login' to verify agent registration)")
+        print()
+        print(f"  Stop  : forgexa daemon stop")
+        print(f"  Logs  : forgexa daemon logs -f")
+
     else:
-        # Foreground mode: run daemon directly
-        print(f"Starting daemon (server: {server_url})...")
-        print("Press Ctrl+C to stop.\n")
+        # ── Foreground mode ──────────────────────────────────────────────────
+        # Scan agents locally for immediate friendly display, then run the daemon
+        # with console log suppressed so raw log lines don't flood the terminal.
+        print(f"Starting daemon  (server: {server_url})")
+        print()
+        print("  Scanning for AI agents...")
+        agents = _scan_local_agents()
+        _show_discovered_agents(agents)
+        print()
+        print("  Press Ctrl+C to stop.  Logs → forgexa daemon logs -f")
+        print()
+
+        # Suppress raw console log output; logs still written to file
+        os.environ["DAEMON_NO_CONSOLE_LOG"] = "1"
         from forgexa_cli.daemon import main_sync
         main_sync()
 
 
+def cmd_daemon_logs(args: argparse.Namespace) -> None:
+    """Show daemon log output; optionally stream new lines like tail -f."""
+    log_path = Path.home() / ".forgexa" / "daemon" / "daemon.log"
+
+    if not log_path.exists():
+        print(f"No daemon log found.")
+        print(f"  Expected : {log_path}")
+        print()
+        print("Start the daemon first:  forgexa daemon start -d")
+        return
+
+    lines  = getattr(args, "lines",  50)
+    follow = getattr(args, "follow", False)
+
+    # Print last N lines
+    try:
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            all_lines = f.readlines()
+        tail = all_lines[-lines:] if len(all_lines) > lines else all_lines
+        for line in tail:
+            print(line, end="")
+    except OSError as exc:
+        print(f"Cannot read log file: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    if not follow:
+        return
+
+    # Follow / tail-f mode
+    print(f"\n--- streaming {log_path}  (Ctrl+C to stop) ---\n", flush=True)
+    try:
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            f.seek(0, 2)  # jump to end
+            while True:
+                chunk = f.read(65536)
+                if chunk:
+                    print(chunk, end="", flush=True)
+                else:
+                    time.sleep(0.15)
+    except KeyboardInterrupt:
+        print()  # ensure newline after Ctrl+C
+
+
+def cmd_daemon_agents(args: argparse.Namespace) -> None:
+    """List all AI agents across every registered daemon runtime."""
+    runtimes = _get_runtimes(include_all=getattr(args, "all", False))
+    if not runtimes:
+        print("No daemons registered.")
+        return
+
+    rows: list[list[str]] = []
+    for r in runtimes:
+        runtime_id = r["id"][:8]
+        daemon_id  = r.get("daemon_id", "")
+        device     = r.get("device_name", "")
+        status     = r.get("status", "")
+        agents     = r.get("available_agents", []) or []
+
+        if not agents:
+            rows.append([runtime_id, daemon_id, device, status, "(none)", "", ""])
+        else:
+            first = True
+            for a in agents:
+                if isinstance(a, dict):
+                    agent_id = a.get("agent_id", "?")
+                    version  = a.get("version",  "")
+                    compat   = a.get("compatibility_level", "")
+                else:
+                    agent_id, version, compat = str(a), "", ""
+                rows.append([
+                    runtime_id if first else "",
+                    daemon_id  if first else "",
+                    device     if first else "",
+                    status     if first else "",
+                    agent_id,
+                    version,
+                    compat,
+                ])
+                first = False
+
+    _print_table(
+        ["Runtime", "Daemon", "Device", "Status", "Agent", "Version", "Compat"],
+        rows,
+    )
+
+
 def cmd_runtimes_list(args: argparse.Namespace) -> None:
     runtimes = _get_runtimes(include_all=getattr(args, "all", False))
     if not runtimes:
@@ -1002,12 +1339,53 @@ def main() -> None:
     # daemon (remote API only — use forgexa-daemon for local daemon management)
     daemon_p = sub.add_parser("daemon", help="Daemon management")
     daemon_sub = daemon_p.add_subparsers(dest="daemon_cmd")
-    daemon_start_p = daemon_sub.add_parser("start", help="Start local daemon (discovers and registers AI agents)")
-    daemon_start_p.add_argument("-d", "--detach", action="store_true", help="Run in background")
+
+    daemon_start_p = daemon_sub.add_parser(
+        "start",
+        help="Start local daemon (discovers and registers AI agents)",
+    )
+    daemon_start_p.add_argument(
+        "-d", "--detach",
+        action="store_true",
+        help="Run in background (recommended for production use)",
+    )
     daemon_start_p.add_argument("--server-url", default=None, help="Server URL to connect to")
-    daemon_status_p = daemon_sub.add_parser("status", help="Show your daemon statuses (from server)")
+
+    daemon_stop_p = daemon_sub.add_parser("stop", help="Stop local daemon (sends SIGTERM)")
+
+    daemon_restart_p = daemon_sub.add_parser(
+        "restart",
+        help="Restart local daemon (stop + start in background)",
+    )
+    daemon_restart_p.add_argument("--server-url", default=None, help="Server URL to connect to")
+
+    daemon_status_p = daemon_sub.add_parser(
+        "status",
+        help="Show local daemon status and registered agents",
+    )
     daemon_status_p.add_argument("--all", action="store_true", help="List all runtimes (platform admin only)")
-    daemon_sub.add_parser("stop", help="Stop local daemon (sends SIGTERM)")
+    daemon_status_p.add_argument("-v", "--verbose", action="store_true", help="Expanded per-agent detail")
+
+    daemon_logs_p = daemon_sub.add_parser(
+        "logs",
+        help="Show daemon log output (optionally stream like tail -f)",
+    )
+    daemon_logs_p.add_argument(
+        "-n", "--lines",
+        type=int, default=50, metavar="N",
+        help="Show last N lines before following (default: 50)",
+    )
+    daemon_logs_p.add_argument(
+        "-f", "--follow",
+        action="store_true",
+        help="Stream new log lines as they arrive (like tail -f)",
+    )
+
+    daemon_agents_p = daemon_sub.add_parser(
+        "agents",
+        help="List all AI agents across registered daemons",
+    )
+    daemon_agents_p.add_argument("--all", action="store_true", help="Include all users' runtimes (admin only)")
 
     # runtimes
     rt_p = sub.add_parser("runtimes", help="Runtime management")
@@ -1104,9 +1482,12 @@ def main() -> None:
             "set": cmd_config_set,
         }.get(a.config_cmd, lambda _: config_p.print_help())(a),
         "daemon": lambda a: {
-            "start": cmd_daemon_start,
-            "status": cmd_daemon_status,
-            "stop": cmd_daemon_stop,
+            "start":   cmd_daemon_start,
+            "stop":    cmd_daemon_stop,
+            "restart": cmd_daemon_restart,
+            "status":  cmd_daemon_status,
+            "logs":    cmd_daemon_logs,
+            "agents":  cmd_daemon_agents,
         }.get(a.daemon_cmd, lambda _: daemon_p.print_help())(a),
         "runtimes": lambda a: {
             "list": cmd_runtimes_list,

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.13.1
+Version: 1.13.3
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.13.1"
+version = "1.13.3"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = { text = "MIT" }

{forgexa_cli-1.13.1 → forgexa_cli-1.13.3}/tests/test_auth_and_runtime_commands.py

@@ -244,6 +244,7 @@ def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -
     monkeypatch.setattr(main.importlib.util, "find_spec", lambda name: object() if name == "pip" else None)
     monkeypatch.setattr(main, "_is_user_site_install", lambda root: True)
     monkeypatch.setattr(main, "_is_virtualenv", lambda: False)
+    monkeypatch.setattr(main, "_is_pep668_environment", lambda: False)
     monkeypatch.setattr(main.sys, "executable", "/usr/bin/python3")
 
     plan = main._build_upgrade_plan("1.12.3")
@@ -260,6 +261,41 @@ def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -
     ]
 
 
+def test_build_upgrade_plan_adds_break_system_packages_on_pep668(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "_cli_distribution", lambda: SimpleNamespace(version="1.13.1"))
+    monkeypatch.setattr(main, "_distribution_root", lambda dist: Path("/usr/lib/python3/dist-packages"))
+    monkeypatch.setattr(main, "_running_from_distribution_root", lambda root: True)
+    monkeypatch.setattr(main, "_direct_url_metadata", lambda dist: None)
+    monkeypatch.setattr(main, "_looks_like_pipx_environment", lambda python=None: False)
+    monkeypatch.setattr(main.importlib.util, "find_spec", lambda name: object() if name == "pip" else None)
+    monkeypatch.setattr(main, "_is_user_site_install", lambda root: True)
+    monkeypatch.setattr(main, "_is_virtualenv", lambda: False)
+    monkeypatch.setattr(main, "_is_pep668_environment", lambda: True)
+    monkeypatch.setattr(main.sys, "executable", "/usr/bin/python3")
+
+    plan = main._build_upgrade_plan(None)
+
+    assert "--break-system-packages" in plan.command
+    assert "--user" in plan.command
+    assert plan.command[-1] == "forgexa-cli"
+
+
+def test_pep668_detection_returns_false_in_normal_venv(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main.sys, "prefix", str(tmp_path))
+    import sysconfig as _sc
+    monkeypatch.setattr(_sc, "get_path", lambda name, **kw: str(tmp_path))
+
+    assert main._is_pep668_environment() is False
+
+
+def test_pep668_detection_returns_true_when_marker_present(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    (tmp_path / "EXTERNALLY-MANAGED").write_text("[externally-managed]\n")
+    import sysconfig as _sc
+    monkeypatch.setattr(_sc, "get_path", lambda name, **kw: str(tmp_path))
+
+    assert main._is_pep668_environment() is True
+
+
 def test_build_upgrade_plan_rejects_editable_install(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(main, "_cli_distribution", lambda: SimpleNamespace(version="1.12.2"))
     monkeypatch.setattr(main, "_distribution_root", lambda dist: Path("/installed/site-packages"))