forgexa-cli 1.13.4__tar.gz → 1.13.6__tar.gz

{forgexa_cli-1.13.4 → forgexa_cli-1.13.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.13.4
+Version: 1.13.6
 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.4 → forgexa_cli-1.13.6}/forgexa_cli/__init__.py

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

{forgexa_cli-1.13.4 → forgexa_cli-1.13.6}/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.4"
+DAEMON_VERSION = "1.13.6"
 
 
 def _detect_client_type() -> str:
@@ -1585,6 +1585,14 @@ class WorkspaceManager:
             "connection closed",
             "connection refused",
             "network is unreachable",
+            # DNS resolution failures — transient (network reconnect, DHCP renewal,
+            # macOS resolver flap).  macOS/BSD SSH prints "nodename nor servname
+            # provided"; Linux SSH/git prints "name or service not known" or
+            # "temporary failure in name resolution".
+            "nodename nor servname",
+            "name or service not known",
+            "could not resolve host",
+            "temporary failure in name resolution",
         )
         return any(marker in err for marker in retry_markers)
 
@@ -2899,9 +2907,12 @@ class ProcessManager:
         "connection reset",
         "connection timed out",
         "connection error",
+        "failed to get response from the ai model",
         "name or service not known",
         "no such host",
         "network is unreachable",
+        "websockettransporterror",
+        "websocket receive failed",
         # "api error" removed: too broad — matches agent-generated code/output
         # discussing API errors. Real API transport errors are covered by the
         # connection patterns above (refused, reset, timed out, etc.).
@@ -3032,6 +3043,21 @@ class ProcessManager:
                         else:
                             has_result = True
                             has_meaningful_content = True
+            elif ev_type == "session.error":
+                err = data.get("data") or {}
+                if isinstance(err, dict):
+                    msg = (
+                        err.get("message")
+                        or err.get("error")
+                        or err.get("errorType")
+                        or ""
+                    )
+                    if msg:
+                        error_messages.append(str(msg))
+                elif isinstance(err, str) and err.strip():
+                    error_messages.append(err)
+                elif isinstance(data.get("message"), str) and data.get("message", "").strip():
+                    error_messages.append(data["message"])
             elif ev_type == "error":
                 msg = data.get("message", "")
                 if msg:
@@ -3137,6 +3163,31 @@ class ProcessManager:
             and not signals["error_messages"]
         )
 
+    @staticmethod
+    def _copilot_called_any_tools(stdout: str) -> bool:
+        """Return True if the Copilot output contains at least one tool call.
+
+        Used to distinguish an early API-rejection failure (exitCode=1 with
+        no work done) from a mid-run failure where the CLI did attempt tool
+        calls before encountering an error.
+        """
+        for raw in (stdout or "").split("\n"):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(data, dict):
+                ev = data.get("type", "")
+                # tool.execution_start / tool_use / assistant.tool_calls are
+                # all signals that at least one tool was invoked.
+                if ev in ("tool.execution_start", "tool_use", "tool_result",
+                          "tool.execution_complete", "assistant.tool_calls"):
+                    return True
+        return False
+
     @staticmethod
     def is_rate_limited(result: "TaskResult") -> bool:
         """Check if an agent failure warrants trying a different agent.
@@ -4097,6 +4148,8 @@ class ProcessManager:
     async def _run_copilot(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
+        *,
+        _retry_without_effort: bool = False,
     ) -> TaskResult:
         """Run GitHub Copilot CLI in non-interactive JSON-streaming mode.
 
@@ -4105,30 +4158,50 @@ class ProcessManager:
         ``gh auth login`` or GITHUB_TOKEN env var must be set.
 
         Flags:
-          -p / --prompt     Non-interactive prompt (exits after completion).
+          -p / --prompt          Non-interactive prompt (exits after completion).
           --output-format json   JSONL stream of session events.
-          --allow-all       Grant all tool + path + URL permissions required
-                            for autonomous file-editing tasks.
-          -C <dir>          Change working directory before execution.
+          --allow-all            Grant all tool + path + URL permissions required
+                                 for autonomous file-editing tasks.
+          -C <dir>               Change working directory before execution.
+
+        Compatibility note:
+          ``--effort`` is only included when ``FACTORY_COPILOT_REASONING`` is
+          explicitly set to a non-empty value.  Older Copilot CLI releases (and
+          some VS Code–bundled variants) don't accept ``--effort``; passing it
+          makes the CLI return exitCode=1 in the JSONL result event immediately
+          without calling any tools.  Making it opt-in avoids this incompatibility
+          while still allowing operators to tune effort on supported versions.
         """
         env = os.environ.copy()
         env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
         env["COPILOT_HOME"] = self._prepare_copilot_home()
 
         model_override = os.environ.get("FACTORY_COPILOT_MODEL")
-        reasoning = os.environ.get("FACTORY_COPILOT_REASONING", "medium")
+        # FACTORY_COPILOT_REASONING is opt-in: only pass --effort when the env
+        # var is explicitly set to a non-empty string.  The default (unset / "")
+        # intentionally omits --effort so that Copilot CLI versions that don't
+        # support the flag don't immediately fail with exitCode=1.
+        reasoning = os.environ.get("FACTORY_COPILOT_REASONING", "").strip()
 
         cmd = [
             agent.command,
             "--output-format", "json",
             "--allow-all",
-            "--effort", reasoning,
-            "-C", str(cwd),
-            "-p", prompt,
         ]
+        if reasoning and not _retry_without_effort:
+            cmd += ["--effort", reasoning]
+        cmd += ["-C", str(cwd), "-p", prompt]
         if model_override:
             cmd = [agent.command, "--model", model_override] + cmd[1:]
 
+        # Log the exact invocation (redact prompt body) so operators can
+        # reproduce failures manually and diagnose CLI version incompatibilities.
+        _cmd_display = " ".join(
+            f'"{a}"' if " " in a else a
+            for a in cmd[:-1]  # omit the -p value (potentially huge/sensitive)
+        ) + ' -p "<prompt>"'
+        logger.debug("Copilot invocation for task %s: %s", task_id, _cmd_display)
+
         try:
             proc = await asyncio.create_subprocess_exec(
                 *cmd,
@@ -4151,7 +4224,27 @@ 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)
+            signals = self._extract_output_signals(stdout)
+            completed_without_result = 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"]
+            )
+            structured_errors = [
+                str(msg).strip()
+                for msg in (signals.get("error_messages") or [])
+                if str(msg).strip()
+            ]
+            copilot_specific_error = ""
+            for msg in reversed(structured_errors):
+                prefix = "Copilot exited with code "
+                suffix = msg[len(prefix):].strip() if msg.startswith(prefix) else ""
+                if not (msg.startswith(prefix) and suffix.isdigit()):
+                    copilot_specific_error = msg
+                    break
             effective_rc = copilot_exit if copilot_exit is not None else returncode
 
             if effective_rc == 0 and returncode == 0:
@@ -4178,12 +4271,56 @@ class ProcessManager:
                     metrics=metrics,
                 )
             else:
+                # --- Immediate-failure retry ladder ---
+                # If Copilot exited with code 1 and no tools were called, the CLI
+                # rejected the initial API request before doing any work. This is a
+                # flag-incompatibility or auth/quota symptom; retry with progressively
+                # stripped flags to auto-heal across CLI versions.
+                #
+                # Retry 1: drop --effort (added in newer ghcs; unsupported in older
+                #          VS Code-bundled versions).
+                # Retry 2: if still failing AND we haven't already tried both drops,
+                #          the error is likely auth/quota — log actionable hint.
+                _no_tools = not self._copilot_called_any_tools(stdout)
+                if (
+                    effective_rc == 1
+                    and _no_tools
+                    and reasoning
+                    and not _retry_without_effort
+                    and not copilot_specific_error
+                ):
+                    logger.warning(
+                        "Copilot exitCode=1 with no tool calls for task %s — "
+                        "retrying without --effort (flag may be unsupported by this CLI version). "
+                        "Invocation was: %s",
+                        task_id, _cmd_display,
+                    )
+                    return await self._run_copilot(
+                        agent, prompt, cwd, timeout, task_id, on_chunk,
+                        _retry_without_effort=True,
+                    )
+                # Exhausted retries — emit an actionable diagnostic hint
+                if effective_rc == 1 and _no_tools and not copilot_specific_error:
+                    logger.error(
+                        "Copilot exitCode=1 with no tool calls for task %s after retries. "
+                        "Likely causes: (1) GitHub auth expired — run `gh auth status` and "
+                        "`gh auth login --scopes copilot`; (2) Copilot subscription inactive; "
+                        "(3) --allow-all flag not supported by this CLI version (%s). "
+                        "To reproduce manually: %s",
+                        task_id, agent.version, _cmd_display,
+                    )
+                if copilot_specific_error:
+                    failure_error = copilot_specific_error[:1500]
+                elif stderr.strip():
+                    failure_error = f"Copilot exited with code {effective_rc}: {stderr[-500:].strip()}"
+                else:
+                    failure_error = f"Copilot exited with code {effective_rc}"
                 return TaskResult(
                     status="failed",
                     exit_code=effective_rc,
                     stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
                     stderr=stderr[-10000:],
-                    error=f"Copilot exited with code {effective_rc}: {stderr[-500:]}",
+                    error=failure_error,
                     metrics=metrics,
                 )
         except asyncio.TimeoutError as exc:
@@ -6668,8 +6805,36 @@ class RuntimeDaemon:
                         if not intents:
                             issues.append("test-intent.json contains no test intents")
                         for ti in intents[:20]:
-                            if not ti.get("id") or not (ti.get("title") or ti.get("description")):
-                                issues.append(f"Test intent missing 'id' or 'title'/'description': {ti.get('id', '?')}")
+                            # Accept common alternative field names that agents generate:
+                            # id      → also accept "test_id", "intent_id"
+                            # title   → also accept "description", "summary", "name"
+                            _ti_id = (
+                                ti.get("id")
+                                or ti.get("test_id")
+                                or ti.get("intent_id")
+                            )
+                            _ti_label = (
+                                ti.get("title")
+                                or ti.get("description")
+                                or ti.get("summary")
+                                or ti.get("name")
+                            )
+                            if not _ti_id or not _ti_label:
+                                # Include actual keys present so the retry prompt gives
+                                # the agent precise feedback on what to fix.
+                                _present_keys = list(ti.keys())[:8]
+                                if not _ti_id:
+                                    issues.append(
+                                        f"Test intent missing required 'id' field "
+                                        f"(found keys: {_present_keys}). "
+                                        f"Each intent MUST have an 'id' field (e.g. \"id\": \"TI-001\")."
+                                    )
+                                else:
+                                    issues.append(
+                                        f"Test intent '{_ti_id}' missing required 'title' or 'description' field "
+                                        f"(found keys: {_present_keys}). "
+                                        f"Each intent MUST have a 'title' field (e.g. \"title\": \"...\")."
+                                    )
                                 break
                     except _json.JSONDecodeError as e:
                         issues.append(f"test-intent.json is not valid JSON: {e}")

{forgexa_cli-1.13.4 → forgexa_cli-1.13.6}/forgexa_cli/main.py

@@ -27,6 +27,16 @@ Usage:
     forgexa gates pending
     forgexa config show
     forgexa --help
+
+Daemon shortcut commands (aliases — no need to type `daemon`):
+    forgexa start -d
+    forgexa stop
+    forgexa restart
+    forgexa status
+    forgexa status --verbose
+    forgexa logs -f
+    forgexa logs -n 100 -f
+    forgexa agents
 """
 from __future__ import annotations
 
@@ -1387,6 +1397,59 @@ def main() -> None:
     )
     daemon_agents_p.add_argument("--all", action="store_true", help="Include all users' runtimes (admin only)")
 
+    # ── Daemon shortcut commands ───────────────────────────────────────────────
+    # Top-level aliases so users can type `forgexa start` instead of
+    # `forgexa daemon start`. Both forms are fully equivalent.
+    _start_sc = sub.add_parser(
+        "start",
+        help="Start local daemon  (alias: forgexa daemon start)",
+    )
+    _start_sc.add_argument(
+        "-d", "--detach",
+        action="store_true",
+        help="Run in background (recommended for production use)",
+    )
+    _start_sc.add_argument("--server-url", default=None, help="Server URL to connect to")
+
+    sub.add_parser(
+        "stop",
+        help="Stop local daemon  (alias: forgexa daemon stop)",
+    )
+
+    _restart_sc = sub.add_parser(
+        "restart",
+        help="Restart local daemon  (alias: forgexa daemon restart)",
+    )
+    _restart_sc.add_argument("--server-url", default=None, help="Server URL to connect to")
+
+    _status_sc = sub.add_parser(
+        "status",
+        help="Daemon status and agents  (alias: forgexa daemon status)",
+    )
+    _status_sc.add_argument("--all", action="store_true", help="List all runtimes (platform admin only)")
+    _status_sc.add_argument("-v", "--verbose", action="store_true", help="Expanded per-agent detail")
+
+    _logs_sc = sub.add_parser(
+        "logs",
+        help="Stream daemon logs  (alias: forgexa daemon logs)",
+    )
+    _logs_sc.add_argument(
+        "-n", "--lines",
+        type=int, default=50, metavar="N",
+        help="Show last N lines before following (default: 50)",
+    )
+    _logs_sc.add_argument(
+        "-f", "--follow",
+        action="store_true",
+        help="Stream new log lines as they arrive (like tail -f)",
+    )
+
+    _agents_sc = sub.add_parser(
+        "agents",
+        help="List AI agents  (alias: forgexa daemon agents)",
+    )
+    _agents_sc.add_argument("--all", action="store_true", help="Include all users' runtimes (admin only)")
+
     # runtimes
     rt_p = sub.add_parser("runtimes", help="Runtime management")
     rt_sub = rt_p.add_subparsers(dest="rt_cmd")
@@ -1489,6 +1552,13 @@ def main() -> None:
             "logs":    cmd_daemon_logs,
             "agents":  cmd_daemon_agents,
         }.get(a.daemon_cmd, lambda _: daemon_p.print_help())(a),
+        # Daemon shortcut aliases (identical handlers, no `daemon` prefix needed)
+        "start":   cmd_daemon_start,
+        "stop":    cmd_daemon_stop,
+        "restart": cmd_daemon_restart,
+        "status":  cmd_daemon_status,
+        "logs":    cmd_daemon_logs,
+        "agents":  cmd_daemon_agents,
         "runtimes": lambda a: {
             "list": cmd_runtimes_list,
         }.get(a.rt_cmd, lambda _: rt_p.print_help())(a),

{forgexa_cli-1.13.4 → forgexa_cli-1.13.6}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.13.4
+Version: 1.13.6
 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.4 → forgexa_cli-1.13.6}/pyproject.toml

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