forgexa-cli 1.3.4__tar.gz → 1.5.2__tar.gz

{forgexa_cli-1.3.4 → forgexa_cli-1.5.2}/PKG-INFO

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

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

{forgexa_cli-1.3.4 → forgexa_cli-1.5.2}/forgexa_cli/daemon.py

@@ -37,16 +37,198 @@ try:
 except ImportError:
     fcntl = None  # type: ignore[assignment]
 
-try:
-    import httpx
-except ImportError:
-    # Auto-install httpx when running standalone (e.g., bundled with desktop app)
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "--quiet", "httpx>=0.24"],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.PIPE,
+# ── httpx dependency — robust auto-install for standalone environments ──
+# When running inside the backend package, httpx is a declared dependency and
+# always available.  In standalone contexts (desktop AppImage/DMG/MSI, CLI
+# without [daemon] extra), httpx may be missing.  We try multiple strategies:
+#
+#   1. Direct import (works for backend & CLI[daemon])
+#   2. Import from cached deps dir (~/.forgexa/daemon/deps)
+#   3. Auto-install via pip --target to the cached deps dir
+#      (bypasses PEP 668 / externally-managed-environment on modern distros)
+#   4. Friendly error with OS-specific instructions if all else fails
+_HTTPX_DEPS_DIR = os.path.join(str(Path.home()), ".forgexa", "daemon", "deps")
+
+
+def _try_install_httpx(deps_dir: str) -> tuple[bool, str]:
+    """Try to install httpx to a user-writable directory.
+
+    Uses pip --target which works on:
+    - AppImage (read-only squashfs, system Python)
+    - PEP 668 systems (Ubuntu 23.04+, Fedora 38+) — bypasses externally-managed check
+    - macOS .app bundles (sandboxed Python)
+    - Windows portable installs
+    - Docker containers with read-only system dirs
+
+    Returns (success, error_detail).
+    """
+    os.makedirs(deps_dir, exist_ok=True)
+    python = sys.executable or "python3"
+
+    # Try pip --target first (most universally compatible).
+    # Falls back to --user, then --break-system-packages as last resort.
+    # We explicitly list httpcore alongside httpx because pip --target may
+    # skip transitive deps it finds in system site-packages, even though
+    # they won't be importable from the isolated deps directory.
+    strategies: list[tuple[str, list[str]]] = [
+        (
+            "pip install --target (isolated deps)",
+            [python, "-m", "pip", "install", "--target", deps_dir,
+             "--quiet", "--upgrade", "httpx>=0.24", "httpcore"],
+        ),
+        (
+            "pip install --user",
+            [python, "-m", "pip", "install", "--user", "--quiet",
+             "httpx>=0.24", "httpcore"],
+        ),
+        (
+            "pip install --break-system-packages",
+            [python, "-m", "pip", "install", "--quiet",
+             "--break-system-packages", "httpx>=0.24", "httpcore"],
+        ),
+    ]
+
+    last_error = ""
+    for label, cmd in strategies:
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
+                text=True,
+                timeout=120,
+            )
+            if result.returncode == 0:
+                return True, ""
+            last_error = f"[{label}] exit code {result.returncode}"
+            stderr_text = (result.stderr or "").strip()
+            if stderr_text:
+                # Keep last 5 lines of stderr for diagnostics
+                stderr_lines = stderr_text.splitlines()[-5:]
+                last_error += ": " + " | ".join(stderr_lines)
+        except FileNotFoundError:
+            last_error = f"[{label}] Python not found: {cmd[0]}"
+        except subprocess.TimeoutExpired:
+            last_error = f"[{label}] timed out after 120s"
+        except Exception as exc:
+            last_error = f"[{label}] {type(exc).__name__}: {exc}"
+
+    return False, last_error
+
+
+def _die_missing_httpx(detail: str) -> None:
+    """Print a clear, actionable error and exit when httpx cannot be loaded."""
+    os_name = platform.system()
+    python_path = sys.executable or "(unknown)"
+
+    if os_name == "Linux":
+        hints = [
+            "pip3 install --user httpx",
+            "sudo apt install python3-httpx          # Debian/Ubuntu",
+            "sudo dnf install python3-httpx          # Fedora/RHEL",
+            "pip3 install forgexa-cli[daemon]",
+        ]
+    elif os_name == "Darwin":
+        hints = [
+            "pip3 install httpx",
+            "brew install python3 && pip3 install httpx",
+            "pip3 install forgexa-cli[daemon]",
+        ]
+    elif os_name == "Windows":
+        hints = [
+            "pip install httpx",
+            "pip install forgexa-cli[daemon]",
+        ]
+    else:
+        hints = [
+            "pip3 install httpx",
+            "pip3 install forgexa-cli[daemon]",
+        ]
+
+    hint_lines = "\n".join(f"    {h}" for h in hints)
+    msg = (
+        "\n"
+        "┌─────────────────────────────────────────────────────────────────────┐\n"
+        "│  Forgexa Daemon: missing required dependency 'httpx'               │\n"
+        "└─────────────────────────────────────────────────────────────────────┘\n"
+        "\n"
+        "  The daemon requires the 'httpx' HTTP client library but it could\n"
+        "  not be imported, and automatic installation failed.\n"
+        "\n"
+        f"  Python:    {python_path}\n"
+        f"  Platform:  {os_name} ({platform.machine()})\n"
+        f"  Detail:    {detail}\n"
+        "\n"
+        "  Please install it manually with one of these commands:\n"
+        "\n"
+        f"{hint_lines}\n"
+        "\n"
+        "  Then restart the daemon.\n"
+        "─────────────────────────────────────────────────────────────────────\n"
     )
-    import httpx
+    print(msg, file=sys.stderr)
+    # Machine-readable summary for the desktop app to parse and show as a toast.
+    print(f"DAEMON_ERROR: Missing required Python package 'httpx'. {detail}", file=sys.stderr)
+    sys.exit(1)
+
+
+def _validate_httpx_imports() -> tuple[bool, str]:
+    """Validate that httpx and its critical transitive deps are importable.
+
+    A bare ``import httpx`` can succeed even when httpcore is missing,
+    because httpx lazily imports its transport layer.  We eagerly check
+    the full chain so the daemon fails fast with a clear message instead
+    of crashing mid-operation when ``httpx.AsyncClient()`` tries to load
+    the transport.
+
+    Returns (ok, missing_module_name).
+    """
+    for mod_name in ("httpx", "httpcore"):
+        try:
+            __import__(mod_name)
+        except ImportError:
+            return False, mod_name
+    return True, ""
+
+
+# Actual import sequence
+_httpx_ok, _httpx_missing = _validate_httpx_imports()
+
+if not _httpx_ok:
+    # Check cached deps directory (previous auto-install)
+    if _HTTPX_DEPS_DIR not in sys.path:
+        sys.path.insert(0, _HTTPX_DEPS_DIR)
+    _httpx_ok, _httpx_missing = _validate_httpx_imports()
+
+if not _httpx_ok:
+    # If httpx is present but a sub-dependency (httpcore) is missing,
+    # the deps directory has a partial/stale installation.  Clear it and
+    # purge cached modules so pip does a clean install with all transitive
+    # dependencies.
+    if _httpx_missing != "httpx":
+        shutil.rmtree(_HTTPX_DEPS_DIR, ignore_errors=True)
+        for _mod_key in list(sys.modules):
+            if _mod_key in ("httpx", "httpcore") or \
+               _mod_key.startswith(("httpx.", "httpcore.")):
+                del sys.modules[_mod_key]
+
+    # Attempt auto-install to user-writable deps directory
+    _ok, _err = _try_install_httpx(_HTTPX_DEPS_DIR)
+    if _ok:
+        if _HTTPX_DEPS_DIR not in sys.path:
+            sys.path.insert(0, _HTTPX_DEPS_DIR)
+        _httpx_ok, _httpx_missing = _validate_httpx_imports()
+        if not _httpx_ok:
+            _die_missing_httpx(
+                f"pip install succeeded but '{_httpx_missing}' still cannot "
+                "be imported — check Python version compatibility"
+            )
+    else:
+        _die_missing_httpx(_err)
+
+import httpx  # noqa: E402  — guaranteed available after validation above
+
+del _httpx_ok, _httpx_missing
 
 # ── Settings: graceful fallback when running standalone (outside backend package) ──
 try:
@@ -97,6 +279,10 @@ except (ImportError, ModuleNotFoundError):
         def AGENT_TIMEOUT(self) -> int:
             return int(os.environ.get("AGENT_TIMEOUT", "3600"))
 
+        @property
+        def GIT_CLONE_TIMEOUT(self) -> int:
+            return int(os.environ.get("GIT_CLONE_TIMEOUT", "600"))
+
         @property
         def AGENT_MAX_OUTPUT_SIZE(self) -> int:
             return int(os.environ.get("AGENT_MAX_OUTPUT_SIZE", "100000"))
@@ -117,6 +303,36 @@ except (ImportError, ModuleNotFoundError):
 
     settings = _StandaloneSettings()  # type: ignore[assignment]
 
+# ── Daemon version and client type ────────────────────────────────────────
+# 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.5.2"
+
+
+def _detect_client_type() -> str:
+    """Auto-detect client type from runtime context.
+
+    Priority:
+      1. FORGEXA_CLIENT_TYPE env var (set by desktop Tauri launcher)
+      2. Import context: app.config importable → "server"
+      3. Default: "cli" (standalone pip-installed daemon)
+
+    This allows a single daemon.py source to work correctly regardless
+    of deployment context, making the bundle-daemon.sh copy safe.
+    """
+    env_type = os.environ.get("FORGEXA_CLIENT_TYPE", "").strip().lower()
+    if env_type in ("server", "cli", "desktop"):
+        return env_type
+    # Server: app.config was successfully imported at module level above
+    if "app.config" in sys.modules:
+        return "server"
+    # Default: standalone execution = CLI
+    return "cli"
+
+
+_CLIENT_TYPE = _detect_client_type()
+
 # ── Logging — self-managed file handler ────────────────────────────────
 # The daemon configures its own FileHandler so logs are written to
 # ~/.forgexa/daemon/daemon.log regardless of how the daemon was launched
@@ -331,6 +547,31 @@ class TaskResult:
     git: dict = field(default_factory=dict)
 
 
+# ── Type-aware analysis outputs (inline fallback for standalone daemons) ──
+# Mirrors type_workflow_profiles.py — used when import is unavailable (CLI/Desktop).
+_ANALYSIS_OUTPUTS_BY_TYPE: dict[str, list[str]] = {
+    "feature": ["PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"],
+    "bugfix": ["diagnosis.md", "TASKS.md", "analysis.json", "test-intent.json"],
+    "refactor": ["refactor-plan.md", "TASKS.md", "analysis.json"],
+    "documentation": ["outline.md", "analysis.json"],
+    "improvement": ["improvement-spec.md", "TASKS.md", "analysis.json", "test-intent.json"],
+    "task": ["task-plan.md", "analysis.json"],
+}
+
+
+def _get_analysis_outputs_for_type(req_type: str) -> list[str]:
+    """Get expected analysis output files for a requirement type.
+
+    Tries to use type_workflow_profiles (available in backend context),
+    falls back to inline mapping for standalone daemon execution.
+    """
+    try:
+        from app.services.type_workflow_profiles import get_profile
+        return list(get_profile(req_type).analysis_outputs)
+    except Exception:
+        return _ANALYSIS_OUTPUTS_BY_TYPE.get(req_type, _ANALYSIS_OUTPUTS_BY_TYPE["feature"])
+
+
 # ── Agent Discovery ──
 
 
@@ -848,7 +1089,10 @@ class WorkspaceManager:
 
         # Ensure _main repo is present and up-to-date
         if not main_repo.exists():
-            await self._git("clone", repo_url, str(main_repo), timeout=600, project_key=project_key)
+            await self._git(
+                "clone", "--single-branch", "--no-tags",
+                repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+            )
         else:
             await self._git("fetch", "--all", cwd=main_repo, timeout=300, project_key=project_key)
 
@@ -936,7 +1180,10 @@ class WorkspaceManager:
                         )
                     except Exception:
                         ws_path.mkdir(parents=True, exist_ok=True)
-                        await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                        await self._git(
+                            "clone", "--single-branch", "--no-tags",
+                            repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                        )
                         # Ensure we're on the correct branch after clone
                         try:
                             await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -958,7 +1205,10 @@ class WorkspaceManager:
                 except Exception:
                     # Fallback to simple clone
                     ws_path.mkdir(parents=True, exist_ok=True)
-                    await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                    await self._git(
+                        "clone", "--single-branch", "--no-tags",
+                        repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                    )
                     # Ensure we're on the correct branch after clone
                     try:
                         await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -1066,15 +1316,11 @@ class ProcessManager:
         "usage limit",
         "rate limit",
         "rate_limit",
-        "429",
         "quota exceeded",
         "too many requests",
         "overloaded",
-        "capacity",
-        "try again",
-        "credit",
         "insufficient_quota",
-        "billing",
+        "billing hard limit",
     ]
 
     # Patterns indicating the agent's API is unreachable/misconfigured —
@@ -1086,9 +1332,11 @@ class ProcessManager:
         "connection refused",
         "connection reset",
         "connection timed out",
+        "connection error",
         "name or service not known",
         "no such host",
         "network is unreachable",
+        "api error",
     ]
 
     def __init__(self):
@@ -1139,8 +1387,12 @@ class ProcessManager:
                 elif isinstance(err, str):
                     error_messages.append(err)
             elif ev_type == "result":
-                has_result = True
-                has_meaningful_content = True
+                if data.get("is_error"):
+                    err_text = str(data.get("result", "") or data.get("error", "") or "result marked as error")
+                    error_messages.append(err_text)
+                else:
+                    has_result = True
+                    has_meaningful_content = True
             elif ev_type == "error":
                 msg = data.get("message", "")
                 if msg:
@@ -1182,13 +1434,33 @@ class ProcessManager:
 
         Returns True for rate/quota limits AND API unavailability errors,
         since a different agent (using a different API backend) may succeed.
+
+        IMPORTANT: Only checks stderr and error message.  When exit code is
+        non-zero, also checks the tail of stdout (last 3000 chars) since the
+        error is likely at the end.  When exit code is 0 (agent reported
+        success but _detect_agent_output_failure set status to failed), do
+        NOT scan stdout — it contains the agent's work output (configs, code)
+        which naturally has terms like "rate_limit", "API_RATE_LIMIT_PER_MINUTE"
+        that trigger false positives.
         """
         if result.status == "success":
             return False
-        combined = (result.stdout + result.stderr + result.error).lower()
+        # When exit code is 0, _detect_agent_output_failure already checked
+        # stderr+error for rate-limit patterns.  Don't re-scan stdout here.
+        if result.exit_code == 0:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+            ).lower()
+        else:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+                + "\n" + (result.stdout or "")[-3000:]
+            ).lower()
         return (
-            any(p in combined for p in ProcessManager.RATE_LIMIT_PATTERNS)
-            or any(p in combined for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
+            any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS)
+            or any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
         )
 
     @staticmethod
@@ -1205,8 +1477,16 @@ class ProcessManager:
         if result.status != "success":
             return None
 
-        combined = "\n".join(part for part in (result.stdout, result.stderr, result.error) if part)
-        pattern_failure = ProcessManager._has_failure_pattern(combined)
+        # For exit-code-0 (success) cases, only scan stderr and the error field
+        # for rate-limit / unavailability patterns.  Stdout contains the agent's
+        # actual task output (code, configs, analysis docs) which may legitimately
+        # contain substrings like "rate_limit", "429", "quota", etc. — e.g. writing
+        # a config file with API_RATE_LIMIT_PER_MINUTE=1000 would previously trigger
+        # a false "quota exhaustion" failure even though the agent succeeded.
+        # stdout[-N:] is only safe to scan when the agent already failed (exit != 0),
+        # which is handled by is_rate_limited() called at the orchestrator level.
+        error_only_channels = (result.stderr or "") + "\n" + (result.error or "")
+        pattern_failure = ProcessManager._has_failure_pattern(error_only_channels)
         if pattern_failure:
             return pattern_failure
 
@@ -1320,18 +1600,23 @@ class ProcessManager:
         return normalized
 
     def _required_deliverable_paths(self, task: TaskInfo) -> set[str]:
-        output_dir = str((task.input_data or {}).get("output_dir", "") or "")
+        # For analysis nodes, deliverables live in analysis_output_dir (docs/requirements/...)
+        # For other nodes, use output_dir (docs/implements/...)
+        if task.node_type == "analysis":
+            output_dir = str(
+                (task.input_data or {}).get("analysis_output_dir", "")
+                or (task.input_data or {}).get("output_dir", "")
+                or ""
+            )
+        else:
+            output_dir = str((task.input_data or {}).get("output_dir", "") or "")
         output_dir = output_dir.replace("\\", "/").lstrip("./").rstrip("/")
         if not output_dir:
             return set()
 
         if task.node_type == "analysis":
             req_type = (task.input_data or {}).get("requirement_type", "feature")
-            try:
-                from app.services.type_workflow_profiles import get_profile
-                required_files = list(get_profile(req_type).analysis_outputs)
-            except Exception:
-                required_files = ["PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"]
+            required_files = _get_analysis_outputs_for_type(req_type)
         elif task.node_type == "design":
             required_files = ["design.md"]
         else:
@@ -1342,7 +1627,8 @@ class ProcessManager:
     def _has_required_deliverable_updates(self, task: TaskInfo, *path_lists: list[str] | None) -> bool:
         required_paths = self._required_deliverable_paths(task)
         if not required_paths:
-            return False
+            # Cannot determine required deliverables — skip check (don't fail)
+            return True
 
         changed_paths: set[str] = set()
         for paths in path_lists:
@@ -1502,7 +1788,7 @@ class ProcessManager:
         cmd = [
             agent.command,
             "-p",
-            "--output-format", "json",
+            "--output-format", "stream-json",
             "--verbose",
             "--dangerously-skip-permissions",
         ]
@@ -1584,7 +1870,13 @@ class ProcessManager:
         on_chunk: Any = None,
     ) -> TaskResult:
         """Run OpenCode CLI in non-interactive mode."""
-        cmd = [agent.command, "run", "--format", "json", "--dangerously-skip-permissions", prompt]
+        cmd = [
+            agent.command, "run",
+            "--format", "json",
+            "--dangerously-skip-permissions",
+            "--cwd", str(cwd),
+            prompt,
+        ]
         result = await self._run_cli(cmd, cwd, timeout, task_id, on_chunk=on_chunk)
         parsed_metrics = self._parse_agent_jsonl_output(result.stdout)
         result.metrics.update(parsed_metrics)
@@ -1706,6 +1998,9 @@ class ProcessManager:
                 data = json.loads(stdout.strip())
                 if isinstance(data, dict):
                     parsed.append(data)
+                elif isinstance(data, list):
+                    # Handle JSON array (from --output-format json)
+                    parsed.extend(d for d in data if isinstance(d, dict))
             except (json.JSONDecodeError, ValueError):
                 pass
 
@@ -2182,6 +2477,8 @@ class HeartbeatService:
                         "available_agents": self._agents,
                         "system_metrics": self._collect_system_metrics(),
                         "os_info": get_os_info(),
+                        "daemon_version": DAEMON_VERSION,
+                        "client_type": _CLIENT_TYPE,
                     },
                     timeout=10,
                 )
@@ -2210,6 +2507,76 @@ class HeartbeatService:
             return {}
 
 
+# ── Log Uploader ──
+
+
+class LogUploader:
+    """Periodically uploads daemon log tail to the server for remote viewing."""
+
+    LOG_UPLOAD_INTERVAL = 300  # Upload every 5 minutes
+    LOG_TAIL_LINES = 500  # Last N lines to upload
+
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        server_url: str,
+        runtime_id: str,
+    ):
+        self.client = client
+        self.server_url = server_url.rstrip("/")
+        self.runtime_id = runtime_id
+        self._task: asyncio.Task | None = None
+
+    async def start(self):
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    async def _loop(self):
+        # Initial upload after 30s delay (let daemon stabilize first)
+        await asyncio.sleep(30)
+        while True:
+            try:
+                await self._upload()
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning("Log upload error: %s", e)
+            await asyncio.sleep(self.LOG_UPLOAD_INTERVAL)
+
+    async def _upload(self):
+        """Read daemon log tail and upload to server."""
+        try:
+            if not DAEMON_LOG_PATH.exists():
+                return
+            # Read last N lines efficiently
+            with open(DAEMON_LOG_PATH, "rb") as f:
+                # Seek from end to find last N lines
+                f.seek(0, 2)
+                file_size = f.tell()
+                # Read at most 100KB from end
+                read_size = min(file_size, 100 * 1024)
+                f.seek(file_size - read_size)
+                content = f.read().decode("utf-8", errors="replace")
+
+            # Take last N lines
+            lines = content.split("\n")
+            tail = "\n".join(lines[-self.LOG_TAIL_LINES:])
+
+            await self.client.post(
+                f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/logs",
+                json={"log_tail": tail, "log_lines": self.LOG_TAIL_LINES},
+                timeout=15,
+            )
+        except Exception as e:
+            logger.warning("Failed to upload daemon log: %s", e)
+
 # ── Task Poller ──
 
 
@@ -2296,6 +2663,7 @@ class ServerConnection:
         self.heartbeat: HeartbeatService | None = None
         self.poller: TaskPoller | None = None
         self.reporter: ProgressReporter | None = None
+        self.log_uploader: LogUploader | None = None
         self._auth_failures = 0  # Consecutive auth failure count
         self._max_auth_failures = 3  # Trigger re-registration after this many
         # Short label for logging
@@ -2338,6 +2706,8 @@ class ServerConnection:
                 self.poller.runtime_id = self.runtime_id
             if self.reporter and self.runtime_id:
                 self.reporter.runtime_id = self.runtime_id
+            if self.log_uploader and self.runtime_id:
+                self.log_uploader.runtime_id = self.runtime_id
             self._auth_failures = 0
             logger.info("[%s] Re-registered successfully after token refresh", self.label)
         except Exception as e:
@@ -2364,6 +2734,8 @@ class ServerConnection:
                     "hardware_id": self.hardware_id,
                     "device_name": platform.node(),
                     "os_info": get_os_info(),
+                    "daemon_version": DAEMON_VERSION,
+                    "client_type": _CLIENT_TYPE,
                     "available_agents": agent_dicts,
                     "max_concurrent_tasks": max_concurrent,
                     "capabilities": {
@@ -2434,15 +2806,22 @@ class ServerConnection:
         self.reporter = ProgressReporter(
             self.client, self.server_url, self.runtime_id,
         )
+        self.log_uploader = LogUploader(
+            self.client, self.server_url, self.runtime_id,
+        )
 
     async def start_heartbeat(self):
         if self.heartbeat:
             await self.heartbeat.start()
+        if self.log_uploader:
+            await self.log_uploader.start()
 
     async def stop(self):
         """Stop heartbeat and unregister."""
         if self.heartbeat:
             await self.heartbeat.stop()
+        if self.log_uploader:
+            await self.log_uploader.stop()
         if self.runtime_id:
             try:
                 # Use deregister endpoint (no admin required) instead of DELETE
@@ -2874,15 +3253,15 @@ class RuntimeDaemon:
                 _line_buffer.extend(lines)
 
             async def _progress_ticker():
-                """Flush buffered output lines + update progress % every 10 s."""
+                """Flush buffered output lines + update progress % every 5 s."""
                 import math as _math
                 tick = 0
                 while not progress_stop.is_set():
-                    await asyncio.sleep(10)
+                    await asyncio.sleep(5)
                     if progress_stop.is_set():
                         break
                     tick += 1
-                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 8))), 90)
+                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
                     pid = self.process_manager.active_processes.get(task.task_id)
                     step = "running_agent"
                     if pid:
@@ -2919,7 +3298,26 @@ class RuntimeDaemon:
             tried_agents.add(agent.agent_id)
 
             # ── Agent fallback: if agent hit rate limit or API is unavailable, try next agent ──
+            # Guard: if the agent already produced file changes in the workspace, it DID
+            # meaningful work — don't trigger fallback even if it crashed after completing.
+            # Let the recovery logic (step 4.1) handle non-zero exit with committed work.
+            _skip_fallback = False
             if self.process_manager.is_rate_limited(result):
+                _pre_fallback_git = await self.process_manager._collect_git_info(workspace_path)
+                _pre_fallback_committed = await self.process_manager._collect_git_info_vs_parent(workspace_path)
+                has_workspace_changes = (
+                    bool(_pre_fallback_git.get("files_changed"))
+                    or bool(_pre_fallback_committed.get("files_changed"))
+                )
+                if has_workspace_changes:
+                    logger.info(
+                        "Agent '%s' exited non-zero for task %s but workspace has changes — "
+                        "skipping fallback, proceeding to recovery",
+                        agent.agent_id, task.task_id,
+                    )
+                    _skip_fallback = True
+
+            if self.process_manager.is_rate_limited(result) and not _skip_fallback:
                 logger.warning(
                     "Agent '%s' unavailable/rate-limited for task %s, attempting fallback",
                     agent.agent_id, task.task_id,
@@ -2949,11 +3347,11 @@ class RuntimeDaemon:
                     async def _progress_ticker2():
                         tick = 0
                         while not progress_stop2.is_set():
-                            await asyncio.sleep(10)
+                            await asyncio.sleep(5)
                             if progress_stop2.is_set():
                                 break
                             tick += 1
-                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 8))), 90)
+                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
                             pid = self.process_manager.active_processes.get(task.task_id)
                             step = f"running_agent:{agent.agent_id}"
                             if pid:
@@ -3066,13 +3464,33 @@ class RuntimeDaemon:
             # Existing files from a prior iteration are not sufficient evidence.
             if result.status == "success" and task.node_type in ("analysis", "design"):
                 committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
-                if not self._has_required_deliverable_updates(
+                git_check_passed = self.process_manager._has_required_deliverable_updates(
                     task,
                     pre_commit_git.get("files_changed"),
                     committed_git.get("files_changed"),
                     result.files_changed,
                     (result.git or {}).get("files_changed"),
-                ):
+                )
+                # Fallback: if git-based check fails (e.g., agent auto-committed and
+                # merge-base detection failed), verify files physically exist on disk.
+                # This prevents false failures when git state is unusual but files
+                # are actually present.
+                if not git_check_passed:
+                    required_paths = self.process_manager._required_deliverable_paths(task)
+                    if required_paths:
+                        files_exist = all(
+                            (workspace_path / p).exists() and (workspace_path / p).stat().st_size > 0
+                            for p in required_paths
+                        )
+                        if files_exist:
+                            logger.info(
+                                "Task %s (%s): git diff did not show deliverables but all %d "
+                                "files exist on disk — accepting as success",
+                                task.task_id, task.node_type, len(required_paths),
+                            )
+                            git_check_passed = True
+
+                if not git_check_passed:
                     logger.warning(
                         "Task %s (%s) reported success but did not update required deliverables",
                         task.task_id, task.node_type,
@@ -3099,6 +3517,16 @@ class RuntimeDaemon:
                 if commit_result:
                     # Propagate push/commit errors in metrics so they're visible
                     result.metrics.update(commit_result)
+                    # Push failure is a real problem for downstream nodes — mark
+                    # as failed so the orchestrator can retry (transient network).
+                    if commit_result.get("push_error"):
+                        push_err = commit_result["push_error"]
+                        logger.error(
+                            "Task %s: push failed, marking as failed so retry can attempt push again: %s",
+                            task.task_id, push_err,
+                        )
+                        result.status = "failed"
+                        result.error = f"Git push failed: {push_err}"
                 # Re-collect git info after commit (compare with parent)
                 post_commit_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
                 # Merge: use the pre-commit file list if post-commit is empty
@@ -3201,15 +3629,13 @@ class RuntimeDaemon:
 
         if node_type == "analysis":
             # Use type profile to determine required analysis outputs
-            try:
-                from app.services.type_workflow_profiles import get_profile
-                profile = get_profile(req_type)
-                required_files = profile.analysis_outputs
-            except Exception:
-                # Fallback to full set if profile import fails
-                required_files = ["PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json"]
+            required_files = _get_analysis_outputs_for_type(req_type)
 
-            doc_dir = (task.input_data or {}).get("output_dir", "")
+            # Analysis deliverables live in analysis_output_dir (docs/requirements/...)
+            doc_dir = (
+                (task.input_data or {}).get("analysis_output_dir", "")
+                or (task.input_data or {}).get("output_dir", "")
+            )
             if doc_dir:
                 base = workspace_path / doc_dir
             else:
@@ -3444,20 +3870,25 @@ class RuntimeDaemon:
         always receives the file contents via the completion report and gate
         reviewers can see the analysis documents immediately.
         """
-        doc_dir = (task.input_data or {}).get("output_dir", "")
+        # Analysis deliverables live in analysis_output_dir (docs/requirements/...)
+        doc_dir = (
+            (task.input_data or {}).get("analysis_output_dir", "")
+            or (task.input_data or {}).get("output_dir", "")
+        )
         if not doc_dir:
             return
 
         base = workspace_path / doc_dir.lstrip("./")
-        _ANALYSIS_FILES = ("PRD.md", "SDD.md", "TASKS.md", "analysis.json", "test-intent.json")
-        existing_artifact_paths = {a.get("path", "") for a in result.artifacts}
+        req_type = (task.input_data or {}).get("requirement_type", "feature")
+        _ANALYSIS_FILES = _get_analysis_outputs_for_type(req_type)
+        existing_artifact_paths = {a.get("path", "").replace("\\", "/") for a in result.artifacts}
 
         for fname in _ANALYSIS_FILES:
             fpath = base / fname
             if not fpath.exists() or fpath.stat().st_size == 0:
                 continue
             try:
-                rel_path = str(fpath.relative_to(workspace_path))
+                rel_path = str(fpath.relative_to(workspace_path)).replace("\\", "/")
                 if rel_path in existing_artifact_paths:
                     continue  # already attached
                 content = fpath.read_text(encoding="utf-8", errors="replace")
@@ -3487,13 +3918,13 @@ class RuntimeDaemon:
             return
 
         base = workspace_path / doc_dir.lstrip("./")
-        existing_artifact_paths = {a.get("path", "") for a in result.artifacts}
+        existing_artifact_paths = {a.get("path", "").replace("\\", "/") for a in result.artifacts}
 
         design_path = base / "design.md"
         if not design_path.exists() or design_path.stat().st_size == 0:
             return
         try:
-            rel_path = str(design_path.relative_to(workspace_path))
+            rel_path = str(design_path.relative_to(workspace_path)).replace("\\", "/")
             if rel_path in existing_artifact_paths:
                 return
             content = design_path.read_text(encoding="utf-8", errors="replace")
@@ -3555,6 +3986,8 @@ class RuntimeDaemon:
                     or task.input_data.get("title")
                     or ""
                 )
+                if not isinstance(wi_title, str):
+                    wi_title = str(wi_title)
                 req_key = task.requirement_key or task.work_item.get("requirement_key") or ""
                 if req_key and wi_title:
                     display_title = f"{req_key}: {wi_title}"
@@ -3565,11 +3998,15 @@ class RuntimeDaemon:
                 else:
                     display_title = task.task_id
 
-                commit_msg = await self._build_auto_commit_message(
-                    display_title, task.task_id, task.node_type,
-                    task.agent_type, change_summary,
-                    workspace_path=workspace_path,
-                )
+                try:
+                    commit_msg = await self._build_auto_commit_message(
+                        display_title, task.task_id, task.node_type,
+                        task.agent_type, change_summary,
+                        workspace_path=workspace_path,
+                    )
+                except Exception as msg_err:
+                    logger.warning("Failed to build rich commit message: %s — using fallback", msg_err)
+                    commit_msg = f"{task.node_type}({task.requirement_key or task.task_id}): {display_title}"
                 proc = await asyncio.create_subprocess_exec(
                     "git", "commit", "-m", commit_msg,
                     cwd=str(workspace_path),
@@ -3766,7 +4203,22 @@ class RuntimeDaemon:
         lines: list[str] = []
 
         # Summary — word-wrap at 78 chars
-        summary = (data.get("summary") or "").strip()
+        raw_summary = data.get("summary")
+        if isinstance(raw_summary, dict):
+            # Some agents produce summary as a structured object; extract description
+            summary = (
+                raw_summary.get("description")
+                or raw_summary.get("title")
+                or raw_summary.get("summary")
+                or ""
+            )
+            if not isinstance(summary, str):
+                summary = str(summary) if summary else ""
+        elif isinstance(raw_summary, str):
+            summary = raw_summary
+        else:
+            summary = str(raw_summary) if raw_summary else ""
+        summary = summary.strip()
         if summary:
             words = summary.split()
             current = ""

{forgexa_cli-1.3.4 → forgexa_cli-1.5.2}/forgexa_cli/main.py

@@ -4,17 +4,20 @@ Forgexa CLI — command-line client for the Forgexa platform.
 A lightweight, standalone CLI that communicates with the Forgexa server via REST API.
 Zero external dependencies — uses only Python stdlib.
 
-Configuration:
-    FORGEXA_SERVER_URL   Server URL (default: https://api.forgexa.net)
-    FORGEXA_TOKEN        Bearer token (obtain via `forgexa login`)
+Configuration (in priority order):
+    1. --server-url flag          Per-command override
+    2. FORGEXA_SERVER_URL env var  Session-level override
+    3. ~/.forgexa/config          Saved via `forgexa login --server <url>`
+    4. Build default              https://api.forgexa.net
 
 Usage:
-    forgexa login
+    forgexa login --server https://your-server.com
     forgexa workspace list
     forgexa project list --workspace <id>
     forgexa requirement list --project <id>
     forgexa daemon status
     forgexa gates pending
+    forgexa config show
     forgexa --help
 """
 from __future__ import annotations
@@ -27,23 +30,56 @@ import signal
 import sys
 from pathlib import Path
 
-# ── HTTP helpers (stdlib only) ──
+# ── Build-time default ──
+# Resolved in priority order at runtime (see _api_url()):
+#   1. --server-url flag
+#   2. FORGEXA_SERVER_URL environment variable
+#   3. ~/.forgexa/config  (saved by `forgexa login --server <url>`)
+#   4. This build default
 
-
-# Default server URL — resolved in priority order:
-#   1. FORGEXA_SERVER_URL environment variable (runtime override)
-#   2. _build_config.py   — generated by publish.sh at wheel-build time
-#   3. Hardcoded fallback — https://api.forgexa.net
-#
-# For local development use: FORGEXA_SERVER_URL=http://localhost:8000 forgexa ...
 try:
-    from forgexa_cli._build_config import BUILD_SERVER_URL as _DEFAULT_SERVER_URL
+    from forgexa_cli._build_config import BUILD_SERVER_URL as _BUILD_DEFAULT
 except ImportError:
-    _DEFAULT_SERVER_URL = "https://api.forgexa.net"
+    _BUILD_DEFAULT = "https://api.forgexa.net"
+
+# Module-level override applied by main() when --server-url is passed.
+_SERVER_URL_OVERRIDE: str | None = None
+
+
+# ── Config file helpers (~/.forgexa/config) ──
+
+def _config_path() -> Path:
+    return Path.home() / ".forgexa" / "config"
+
+
+def _load_config() -> dict:
+    p = _config_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_config(data: dict) -> None:
+    p = _config_path()
+    p.parent.mkdir(exist_ok=True)
+    p.write_text(json.dumps(data, indent=2))
+    p.chmod(0o600)
 
 
 def _api_url() -> str:
-    return os.environ.get("FORGEXA_SERVER_URL", _DEFAULT_SERVER_URL)
+    """Resolve the server URL using priority chain."""
+    if _SERVER_URL_OVERRIDE:
+        return _SERVER_URL_OVERRIDE
+    env = os.environ.get("FORGEXA_SERVER_URL")
+    if env:
+        return env
+    cfg = _load_config()
+    if cfg.get("server_url"):
+        return cfg["server_url"]
+    return _BUILD_DEFAULT
 
 
 def _token() -> str | None:
@@ -53,7 +89,8 @@ def _token() -> str | None:
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         return token_file.read_text().strip()
-    return None
+    cfg = _load_config()
+    return cfg.get("token") or None
 
 
 def _headers() -> dict[str, str]:
@@ -157,26 +194,83 @@ def _print_table(headers: list[str], rows: list[list[str]], fmt: str | None = No
 
 
 def cmd_login(args: argparse.Namespace) -> None:
+    # If --server was given, apply it for this login request and save it.
+    server = getattr(args, "server", None)
+    if server:
+        global _SERVER_URL_OVERRIDE
+        _SERVER_URL_OVERRIDE = server.rstrip("/")
+
     email = args.email or input("Email: ")
     password = args.password or getpass.getpass("Password: ")
     result = _post("/auth/login", {"email": email, "password": password})
     token = result.get("access_token", "")
-    # Save token to file
+
+    # Save to config file (server_url + token in one place)
+    cfg = _load_config()
+    if server:
+        cfg["server_url"] = _SERVER_URL_OVERRIDE
+    cfg["token"] = token
+    _save_config(cfg)
+
+    # Also keep the legacy token file for backwards compatibility
     token_dir = Path.home() / ".forgexa"
     token_dir.mkdir(exist_ok=True)
     (token_dir / "token").write_text(token)
     (token_dir / "token").chmod(0o600)
-    print(f"Login successful. Token saved to ~/.forgexa/token")
-    print(f"Or set manually: export FORGEXA_TOKEN={token}")
+
+    active_server = _api_url()
+    print(f"Login successful.")
+    print(f"  Server : {active_server}")
+    print(f"  Config : ~/.forgexa/config")
 
 
 def cmd_logout(_args: argparse.Namespace) -> None:
+    cleared = False
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         token_file.unlink()
+        cleared = True
+    cfg = _load_config()
+    if "token" in cfg:
+        del cfg["token"]
+        _save_config(cfg)
+        cleared = True
+    if cleared:
         print("Logged out. Token removed.")
     else:
-        print("No token file found.")
+        print("No token found.")
+
+
+def cmd_config_show(_args: argparse.Namespace) -> None:
+    """Show current CLI configuration."""
+    cfg = _load_config()
+    token = _token()
+    active_url = _api_url()
+    source = "build default"
+    if _SERVER_URL_OVERRIDE:
+        source = "--server-url flag"
+    elif os.environ.get("FORGEXA_SERVER_URL"):
+        source = "FORGEXA_SERVER_URL env var"
+    elif cfg.get("server_url"):
+        source = f"~/.forgexa/config"
+    print(f"Server URL : {active_url}  (source: {source})")
+    print(f"Auth token : {'set' if token else 'not set'}")
+    print(f"Config file: {_config_path()}")
+
+
+def cmd_config_set(args: argparse.Namespace) -> None:
+    """Set a configuration value."""
+    cfg = _load_config()
+    if args.key == "server-url":
+        url = args.value.rstrip("/")
+        cfg["server_url"] = url
+        _save_config(cfg)
+        print(f"Server URL set to: {url}")
+        print(f"Saved to: {_config_path()}")
+    else:
+        print(f"Unknown config key: {args.key}", file=sys.stderr)
+        print("Available keys: server-url", file=sys.stderr)
+        sys.exit(1)
 
 
 def cmd_daemon_status(_args: argparse.Namespace) -> None:
@@ -467,20 +561,28 @@ def cmd_version(_args: argparse.Namespace) -> None:
 
 
 def main() -> None:
+    global _SERVER_URL_OVERRIDE, _output_format
+
+    active_url = _api_url()  # resolved before parsing (for help text)
+
     parser = argparse.ArgumentParser(
         prog="forgexa",
         description="Forgexa CLI — communicates with the Forgexa server via REST API.",
         epilog=(
             "Configuration:\n"
-            f"  FORGEXA_SERVER_URL   Server URL (default: {_DEFAULT_SERVER_URL})\n"
-            "  FORGEXA_TOKEN        Bearer token (or use `forgexa login`)\n"
+            f"  Current server : {active_url}\n"
+            "  Change server  : forgexa login --server <url>\n"
+            "                   forgexa config set server-url <url>\n"
+            "                   export FORGEXA_SERVER_URL=<url>\n"
+            "  Auth token     : forgexa login  (saved to ~/.forgexa/config)\n"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument(
         "--server-url",
         default=None,
-        help=f"Server URL (default: $FORGEXA_SERVER_URL or {_DEFAULT_SERVER_URL})",
+        metavar="URL",
+        help="Server URL override for this command (also: $FORGEXA_SERVER_URL or ~/.forgexa/config)",
     )
     parser.add_argument(
         "--format",
@@ -495,10 +597,19 @@ def main() -> None:
 
     # auth
     login_p = sub.add_parser("login", help="Login and save access token")
+    login_p.add_argument("--server", metavar="URL", help="Server URL to connect to (saved to ~/.forgexa/config)")
     login_p.add_argument("--email", help="Email address")
     login_p.add_argument("--password", help="Password")
     sub.add_parser("logout", help="Remove saved access token")
 
+    # config
+    config_p = sub.add_parser("config", help="View or change CLI configuration")
+    config_sub = config_p.add_subparsers(dest="config_cmd")
+    config_sub.add_parser("show", help="Show current configuration")
+    cfg_set = config_sub.add_parser("set", help="Set a configuration value")
+    cfg_set.add_argument("key", choices=["server-url"], help="Config key")
+    cfg_set.add_argument("value", help="Config value")
+
     # 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")
@@ -583,9 +694,8 @@ def main() -> None:
     args = parser.parse_args()
 
     if args.server_url:
-        os.environ["FORGEXA_SERVER_URL"] = args.server_url
+        _SERVER_URL_OVERRIDE = args.server_url.rstrip("/")
 
-    global _output_format
     _output_format = args.format or "table"
 
     cmd = args.command
@@ -597,6 +707,10 @@ def main() -> None:
         "version": cmd_version,
         "login": cmd_login,
         "logout": cmd_logout,
+        "config": lambda a: {
+            "show": cmd_config_show,
+            "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,

{forgexa_cli-1.3.4 → forgexa_cli-1.5.2}/forgexa_cli.egg-info/PKG-INFO

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

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