forgexa-cli 1.47.3__tar.gz → 1.47.4__tar.gz

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.3
+Version: 1.47.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT
@@ -132,10 +132,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/README.md

@@ -100,10 +100,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/forgexa_cli/__init__.py

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

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/forgexa_cli/daemon.py

@@ -197,6 +197,7 @@ def _windows_daemon_process_query(exclude_pid: int) -> str:
 
 
 _LOCAL_RUNTIME_REGISTRATION_SCHEMA_VERSION = 1
+_DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION = 1
 
 
 def _local_runtime_registration_path() -> Path:
@@ -210,6 +211,47 @@ def _local_runtime_registration_path() -> Path:
     return Path.home() / ".forgexa" / "daemon" / "runtime-registrations.json"
 
 
+def _desktop_daemon_restart_request_path(instance_id: str) -> Path:
+    return (
+        Path.home()
+        / ".forgexa"
+        / "daemon"
+        / "restart-requests"
+        / f"{instance_id}.json"
+    )
+
+
+def _desktop_daemon_restart_target_version(instance_id: str) -> str | None:
+    """Return a restart target only when the request belongs to this daemon."""
+    try:
+        request = json.loads(
+            _desktop_daemon_restart_request_path(instance_id).read_text(encoding="utf-8")
+        )
+    except (OSError, ValueError):
+        return None
+    if not isinstance(request, dict):
+        return None
+    if request.get("schema_version") != _DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION:
+        return None
+    if request.get("instance_id") != instance_id:
+        return None
+    target_version = request.get("target_version")
+    return target_version.strip() if isinstance(target_version, str) and target_version.strip() else None
+
+
+def _clear_desktop_daemon_restart_request(instance_id: str) -> None:
+    path = _desktop_daemon_restart_request_path(instance_id)
+    try:
+        request = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(request, dict) or request.get("instance_id") != instance_id:
+            return
+        path.unlink(missing_ok=True)
+    except FileNotFoundError:
+        return
+    except (OSError, ValueError):
+        logger.warning("Failed to clear desktop daemon restart request")
+
+
 def _write_local_runtime_registration_snapshot(
     instance_id: str,
     state: str,
@@ -221,13 +263,16 @@ def _write_local_runtime_registration_snapshot(
         "schema_version": _LOCAL_RUNTIME_REGISTRATION_SCHEMA_VERSION,
         "pid": os.getpid(),
         "instance_id": instance_id,
+        "daemon_version": DAEMON_VERSION,
+        "client_type": _CLIENT_TYPE,
+        "desktop_restart_protocol_version": _DESKTOP_DAEMON_RESTART_REQUEST_SCHEMA_VERSION,
         "updated_at": int(time.time()),
         "state": state,
         "registrations": registrations,
     }
     try:
         path.parent.mkdir(parents=True, exist_ok=True)
-        tmp_path = path.with_name(path.name + ".tmp")
+        tmp_path = path.with_name(f"{path.name}.{os.getpid()}.tmp")
         tmp_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
         if os.name != "nt":
             os.chmod(tmp_path, 0o600)
@@ -1075,7 +1120,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.47.3"
+DAEMON_VERSION = "1.47.4"
 
 
 def _detect_client_type() -> str:
@@ -1508,14 +1553,19 @@ def _filter_local_bind_task_result(result: "TaskResult") -> None:
     agent observations are classified as data that must NEVER leave the
     user's machine by default for workspace_resolution="local_bind" tasks —
     only Git-tracked artifacts (already pushed) and status/metrics/Git
-    metadata sync. error/failure_code/metrics/git/artifacts/evidence_summary are left as-is
-    (status metadata, not raw output) — only stdout/stderr tail and raw
-    agent observations are cleared. Mutates `result` in place; call this
-    right before ProgressReporter.report_complete().
+    metadata sync. Failure codes, metrics, Git metadata, artifacts, and
+    evidence summaries are preserved; free-text errors are replaced because
+    they can contain local paths or Agent output. Mutates `result` in place;
+    call this right before ProgressReporter.report_complete().
     """
     result.stdout = ""
     result.stderr = ""
     result.observations = []
+    if result.error:
+        result.error = (
+            "Local task failed. Review this task in Forgexa Desktop on the "
+            "running device."
+        )
 
 def _prepare_ai_job_output(
     *,
@@ -2212,6 +2262,99 @@ def _append_local_bind_output_log(task_id: str, lines: list[str]) -> None:
         logger.warning("Failed to append local-bind output log for task %s: %s", task_id, e)
 
 
+def _local_bind_tool_activity(tool_name: object, completed: bool = False) -> str:
+    """Return a content-free activity label for a local Agent tool event."""
+    normalized = tool_name.lower() if isinstance(tool_name, str) else ""
+    if normalized in {
+        "read", "read_file", "file_read", "file_search", "grep_search",
+        "semantic_search", "search", "list_dir", "glob",
+    }:
+        return "agent.inspecting_files"
+    if normalized in {
+        "write", "create_file", "apply_patch", "str_replace", "str_replace_editor",
+        "file_edit", "file_change", "edit",
+    }:
+        return "agent.updating_files"
+    if normalized in {
+        "bash", "run_in_terminal", "execute_command", "command_execution", "terminal",
+    }:
+        return "agent.completed_command" if completed else "agent.running_command"
+    if normalized in {"get_errors", "lint", "test"}:
+        return "agent.checking_diagnostics"
+    return "agent.using_workspace_tool"
+
+
+def _summarize_local_bind_output(lines: list[str]) -> list[str]:
+    """Derive Web-safe activity labels without returning Agent output content."""
+    activity_lines: list[str] = []
+    seen: set[str] = set()
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        try:
+            event = json.loads(stripped)
+        except json.JSONDecodeError:
+            activity = "agent.producing_output"
+        else:
+            if not isinstance(event, dict):
+                continue
+            event_type = event.get("type")
+            data = event.get("data") if isinstance(event.get("data"), dict) else event
+            activity = None
+
+            if event_type == "tool.execution_start":
+                activity = _local_bind_tool_activity(data.get("toolName"))
+            elif event_type == "assistant.message":
+                activity = (
+                    "agent.planning_next_action"
+                    if data.get("toolRequests")
+                    else "agent.wrote_update"
+                )
+            elif event_type == "assistant":
+                message = event.get("message")
+                content = message.get("content") if isinstance(message, dict) else None
+                if isinstance(content, list):
+                    for item in content:
+                        if not isinstance(item, dict):
+                            continue
+                        if item.get("type") == "tool_use":
+                            activity = _local_bind_tool_activity(item.get("name"))
+                            break
+                        if item.get("type") == "text":
+                            activity = "agent.wrote_update"
+                            break
+            elif event_type in {"item.started", "item.completed"}:
+                item = event.get("item")
+                item_type = item.get("type") if isinstance(item, dict) else None
+                if item_type == "agent_message":
+                    activity = "agent.wrote_update"
+                elif item_type:
+                    activity = _local_bind_tool_activity(
+                        item_type,
+                        completed=event_type == "item.completed",
+                    )
+            elif event_type == "tool_use":
+                part = event.get("part")
+                tool_name = part.get("tool") if isinstance(part, dict) else None
+                activity = _local_bind_tool_activity(tool_name)
+            elif event_type == "text":
+                activity = "agent.wrote_update"
+            elif event_type == "result":
+                activity = (
+                    "agent.reported_error"
+                    if event.get("is_error")
+                    else "agent.completed_response"
+                )
+
+        if activity and activity not in seen:
+            activity_lines.append(activity)
+            seen.add(activity)
+
+    return activity_lines
+
+
 _LOCAL_BIND_SSH_SCHEME_RE = re.compile(r"^ssh://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _LOCAL_BIND_HTTP_SCHEME_RE = re.compile(r"^https?://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _LOCAL_BIND_SCP_LIKE_RE = re.compile(r"^[^@/]+@([^:/]+):(.+?)(?:\.git)?/?$")
@@ -5382,6 +5525,7 @@ class ProcessManager:
                 timeout,
                 task.task_id,
                 on_chunk,
+                stream_stderr=task.workspace_resolution == "local_bind",
                 disable_builtin_mcps=task.input_data.get("task_type") in {
                     "test_script_generate",
                     "qa_scenario_preview",
@@ -6274,6 +6418,7 @@ class ProcessManager:
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
         *,
+        stream_stderr: bool = False,
         disable_builtin_mcps: bool = False,
         _retry_without_effort: bool = False,
         _retry_without_token_env: bool = False,
@@ -6454,6 +6599,7 @@ class ProcessManager:
             stdout, stderr, returncode = await self._stream_process(
                 proc, None, timeout, task_id, on_chunk,
                 workspace_path=cwd,
+                stream_stderr=stream_stderr,
             )
 
             # Parse copilot JSONL output for metrics
@@ -6515,6 +6661,7 @@ class ProcessManager:
                     timeout,
                     task_id,
                     on_chunk,
+                    stream_stderr=stream_stderr,
                     disable_builtin_mcps=True,
                     _retry_without_effort=_retry_without_effort,
                     _retry_without_token_env=_retry_without_token_env,
@@ -6559,6 +6706,7 @@ class ProcessManager:
                         timeout,
                         task_id,
                         on_chunk,
+                        stream_stderr=stream_stderr,
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=_retry_without_effort,
                         _retry_without_token_env=True,
@@ -6622,6 +6770,7 @@ class ProcessManager:
                     )
                     return await self._run_copilot(
                         agent, prompt, cwd, timeout, task_id, on_chunk,
+                        stream_stderr=stream_stderr,
                         disable_builtin_mcps=disable_builtin_mcps,
                         _retry_without_effort=True,
                         _retry_without_token_env=_retry_without_token_env,
@@ -7056,6 +7205,7 @@ class ProgressReporter:
         self.server_url = server_url.rstrip("/")
         self.runtime_id = runtime_id
         self._last_progress_sent: dict[str, dict[str, Any]] = {}
+        self._pending_output_lines: dict[str, list[str]] = {}
 
     def _should_skip_progress(
         self,
@@ -7063,11 +7213,12 @@ class ProgressReporter:
         progress_percent: int,
         current_step: str,
         output_lines: list[str],
+        activity_lines: list[str],
         files_changed: list[str],
         lines_added: int,
         lines_removed: int,
     ) -> bool:
-        if output_lines or files_changed or lines_added or lines_removed:
+        if output_lines or activity_lines or files_changed or lines_added or lines_removed:
             return False
 
         last = self._last_progress_sent.get(task_id)
@@ -7085,47 +7236,68 @@ class ProgressReporter:
         progress_percent: int,
         current_step: str,
         output_lines: list[str] | None = None,
+        activity_lines: list[str] | None = None,
         files_changed: list[str] | None = None,
         lines_added: int = 0,
         lines_removed: int = 0,
-    ):
-        output_lines = output_lines or []
+    ) -> bool:
+        output_lines = [
+            *self._pending_output_lines.get(task_id, []),
+            *(output_lines or []),
+        ]
+        activity_lines = activity_lines or []
         files_changed = files_changed or []
         if self._should_skip_progress(
             task_id,
             progress_percent,
             current_step,
             output_lines,
+            activity_lines,
             files_changed,
             lines_added,
             lines_removed,
         ):
-            return
+            return True
 
         try:
-            await self.client.post(
+            response = await self.client.post(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/tasks/{task_id}/progress",
                 json={
                     "progress_percent": progress_percent,
                     "current_step": current_step,
                     "output_lines": output_lines,
+                    "activity_lines": activity_lines,
                     "files_changed": files_changed,
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
                 },
                 timeout=10,
             )
-            self._last_progress_sent[task_id] = {
-                "progress_percent": progress_percent,
-                "current_step": current_step,
-                "sent_at": time.monotonic(),
-            }
+            if 200 <= response.status_code < 300:
+                self._pending_output_lines.pop(task_id, None)
+                self._last_progress_sent[task_id] = {
+                    "progress_percent": progress_percent,
+                    "current_step": current_step,
+                    "sent_at": time.monotonic(),
+                }
+                return True
+            logger.warning(
+                "Failed to report progress for task %s: server returned %s %s",
+                task_id,
+                response.status_code,
+                response.text[:500],
+            )
         except Exception as e:
-            logger.warning("Failed to report progress for task %s: %s", task_id, e)
+            logger.warning("Failed to report progress for task %s: %s", task_id, _format_exc(e))
+
+        if output_lines:
+            self._pending_output_lines[task_id] = output_lines[-5000:]
+        return False
 
     async def report_complete(self, task_id: str, result: TaskResult):
         """Report task completion with retry."""
         self._last_progress_sent.pop(task_id, None)
+        self._pending_output_lines.pop(task_id, None)
         payload = {
             "status": result.status,
             "exit_code": result.exit_code,
@@ -7717,6 +7889,7 @@ class TaskPoller:
                 self._on_auth_failure()
                 return []
             else:
+                logger.warning("Task poll failed: %s %s", resp.status_code, resp.text[:500])
                 return []
 
             data = resp.json()
@@ -7775,10 +7948,12 @@ class TaskPoller:
                 return data.get("ai_jobs", [])
             elif resp.status_code in (401, 403):
                 self._on_auth_failure()
+            else:
+                logger.warning("AIJob poll failed: %s %s", resp.status_code, resp.text[:500])
             self.cancelled_ai_job_ids = []
             return []
         except Exception as e:
-            logger.debug("AIJob poll error: %s", _format_exc(e))
+            logger.warning("AIJob poll error: %s", _format_exc(e))
             self.cancelled_ai_job_ids = []
             return []
 
@@ -8715,6 +8890,7 @@ class RuntimeDaemon:
         self._shutdown = False
         self._local_runtime_instance_id = secrets.token_urlsafe(18)
         self._local_runtime_registrations: dict[str, dict[str, int | str]] = {}
+        self._desktop_restart_requested = False
 
         # Deployment merge worktree GC: runs at most every 6 hours.
         self._last_merge_gc: float = 0.0
@@ -8801,10 +8977,32 @@ class RuntimeDaemon:
         }
         _write_local_runtime_registration_snapshot(
             self._local_runtime_instance_id,
-            "ready",
+            "draining" if getattr(self, "_desktop_restart_requested", False) else "ready",
             self._local_runtime_registrations,
         )
 
+    def _begin_desktop_restart_drain_if_requested(self) -> bool:
+        target_version = _desktop_daemon_restart_target_version(
+            self._local_runtime_instance_id
+        )
+        if not target_version:
+            return self._desktop_restart_requested
+        if target_version == DAEMON_VERSION:
+            _clear_desktop_daemon_restart_request(self._local_runtime_instance_id)
+            return self._desktop_restart_requested
+        if not self._desktop_restart_requested:
+            self._desktop_restart_requested = True
+            _write_local_runtime_registration_snapshot(
+                self._local_runtime_instance_id,
+                "draining",
+                self._local_runtime_registrations,
+            )
+            logger.info(
+                "Desktop requested daemon restart for version %s; draining active tasks",
+                target_version,
+            )
+        return True
+
     @staticmethod
     def _resolve_task_output_dir(task: TaskInfo) -> str:
         input_data = task.input_data or {}
@@ -9270,7 +9468,16 @@ class RuntimeDaemon:
         # 3. Main loop
         try:
             while not self._shutdown:
-                had_work = await self._poll_and_execute()
+                draining_for_desktop_restart = self._begin_desktop_restart_drain_if_requested()
+                had_work = await self._poll_and_execute(
+                    accept_new_tasks=not draining_for_desktop_restart,
+                )
+                if draining_for_desktop_restart and not self.active_tasks:
+                    logger.info("Desktop daemon drain complete; restarting through the updated client")
+                    self._shutdown = True
+                    continue
+                if self._shutdown:
+                    break
                 next_delay = self.poll_interval
                 if self.connections:
                     next_delay = min(
@@ -9289,7 +9496,7 @@ class RuntimeDaemon:
         finally:
             await self._shutdown_gracefully()
 
-    async def _poll_and_execute(self) -> bool:
+    async def _poll_and_execute(self, *, accept_new_tasks: bool = True) -> bool:
         """Poll for tasks from all connected servers and execute them."""
         had_work = False
 
@@ -9327,11 +9534,11 @@ class RuntimeDaemon:
 
         # Poll from all connected servers
         for conn in self.connections:
-            has_capacity = total_active < self.max_concurrent
+            has_capacity = accept_new_tasks and total_active < self.max_concurrent
             tasks = await conn.poller.poll() if has_capacity else []
             # Always poll AI jobs so server-requested cancellations can stop a
             # process that is itself consuming the last available slot.
-            ai_jobs = await conn.poller.poll_ai_jobs()
+            ai_jobs = await conn.poller.poll_ai_jobs() if accept_new_tasks else []
             _cancel_server_requested_ai_jobs(conn)
             total_active = len(self.active_tasks)
             has_capacity = total_active < self.max_concurrent
@@ -9665,6 +9872,11 @@ class RuntimeDaemon:
         # skipped for a node bound to the user's own real directory. See
         # docs/designs/forgexa-ide-design.md §6.2.
         is_local_bind = task.workspace_resolution == "local_bind"
+        async def report_task_complete(result: TaskResult) -> None:
+            if is_local_bind:
+                _filter_local_bind_task_result(result)
+            await reporter.report_complete(task.task_id, result)
+
         default_branch = str((task.project or {}).get("default_branch") or "").strip()
         node_before_sha = ""
         # Use workspace-level granularity (requirement_workflow_id or graph_id) so that
@@ -9697,7 +9909,7 @@ class RuntimeDaemon:
             )
             if local_bind_file_lock is None:
                 project_lock.release()
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=(
                         "local_binding_unavailable: another process on this "
@@ -9724,7 +9936,7 @@ class RuntimeDaemon:
                 }
                 hint = _INSTALL_HINTS.get(task.agent_type, f"install the '{task.agent_type}' CLI tool")
                 logger.error("No agent found for type '%s' on this runtime", task.agent_type)
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=(
                         f"Agent '{task.agent_type}' is not available on this runtime. "
@@ -9758,7 +9970,7 @@ class RuntimeDaemon:
                 _pf_checks = project_preflight.get("checks", [])
                 _pf_detail = _pf_checks[0].get("detail", "Project preflight failed") if _pf_checks else "Project preflight failed"
                 logger.warning("Project preflight failed for task %s: %s", task.task_id, _pf_detail)
-                await reporter.report_complete(task.task_id, TaskResult(
+                await report_task_complete(TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
                     error=_pf_detail,
                     failure_code="project_preflight_failed",
@@ -9810,9 +10022,10 @@ class RuntimeDaemon:
             # 3. Run agent with real-time output streaming + periodic progress heartbeat
             await reporter.report_progress(task.task_id, 10, "running_agent")
 
-            # Buffer agent output lines between ticks; the ticker flushes them
-            # every 10 seconds so the server accumulates a real-time log.
+            # Buffer cloud output or local-bind activity summaries between
+            # ticks so the server accumulates a real-time, safe display log.
             _line_buffer: list[str] = []
+            last_local_activity: str | None = None
             _task_start = time.monotonic()
             progress_stop = asyncio.Event()
 
@@ -9821,18 +10034,43 @@ class RuntimeDaemon:
 
                 Forgexa IDE local-bind (design doc §6.6/§12.6.2): raw agent
                 terminal output must never leave the user's machine by
-                default — skip buffering into the server-bound progress
-                report entirely (every report_progress() flush below sends
-                an empty output_lines list, not live stdout content).
+                default. A content-free activity summary is sent through the
+                dedicated activity_lines field so Web users can follow task
+                progress without receiving stdout, commands, paths, or text.
                 Instead, append to a local-only, OS-user-private log file so
                 the IDE can still tail it on THIS machine (never sent over
                 HTTP by this module).
                 """
+                nonlocal last_local_activity
                 if is_local_bind:
                     _append_local_bind_output_log(task.task_id, lines)
+                    for activity in _summarize_local_bind_output(lines):
+                        if activity != last_local_activity:
+                            _line_buffer.append(activity)
+                            last_local_activity = activity
                     return
                 _line_buffer.extend(lines)
 
+            async def report_stream_progress(
+                progress_percent: int,
+                current_step: str,
+                output_lines: list[str],
+            ) -> None:
+                if is_local_bind:
+                    await reporter.report_progress(
+                        task.task_id,
+                        progress_percent,
+                        current_step,
+                        activity_lines=output_lines,
+                    )
+                else:
+                    await reporter.report_progress(
+                        task.task_id,
+                        progress_percent,
+                        current_step,
+                        output_lines=output_lines,
+                    )
+
             async def _progress_ticker():
                 """Flush buffered output lines + update progress % every 1 s.
 
@@ -9856,9 +10094,7 @@ class RuntimeDaemon:
                     # Grab and clear the buffer atomically
                     lines_to_send = _line_buffer[:]
                     _line_buffer.clear()
-                    await reporter.report_progress(
-                        task.task_id, pct, step, output_lines=lines_to_send
-                    )
+                    await report_stream_progress(pct, step, lines_to_send)
 
             ticker_task = asyncio.create_task(_progress_ticker())
 
@@ -9877,9 +10113,7 @@ class RuntimeDaemon:
                 if _line_buffer:
                     pid = self.process_manager.active_processes.get(task.task_id)
                     step = f"running_agent (pid={pid.pid})" if pid else "running_agent"
-                    await reporter.report_progress(
-                        task.task_id, 90, step, output_lines=_line_buffer[:]
-                    )
+                    await report_stream_progress(90, step, _line_buffer[:])
                     _line_buffer.clear()
 
             tried_agents.add(agent.agent_id)
@@ -9978,9 +10212,7 @@ class RuntimeDaemon:
                                 step += f" (pid={pid.pid})"
                             lines_to_send = _line_buffer[:]
                             _line_buffer.clear()
-                            await reporter.report_progress(
-                                task.task_id, pct, step, output_lines=lines_to_send
-                            )
+                            await report_stream_progress(pct, step, lines_to_send)
 
                     ticker2 = asyncio.create_task(_progress_ticker2())
                     try:
@@ -9995,9 +10227,10 @@ class RuntimeDaemon:
                         except asyncio.CancelledError:
                             pass
                         if _line_buffer:
-                            await reporter.report_progress(
-                                task.task_id, 90, f"running_agent:{agent.agent_id}",
-                                output_lines=_line_buffer[:],
+                            await report_stream_progress(
+                                90,
+                                f"running_agent:{agent.agent_id}",
+                                _line_buffer[:],
                             )
                             _line_buffer.clear()
 
@@ -10480,19 +10713,14 @@ class RuntimeDaemon:
                     or "validation_retry_exhausted"
                 )
             result.execution_attempt_id = task.execution_attempt_id
-            if is_local_bind:
-                # See docs/designs/forgexa-ide-design.md §6.6 — full terminal
-                # output and raw agent observations must never leave the
-                # user's machine by default.
-                _filter_local_bind_task_result(result)
             await reporter.report_progress(task.task_id, 100, "completed" if result.status == "success" else "failed")
-            await reporter.report_complete(task.task_id, result)
+            await report_task_complete(result)
 
             logger.info("Task %s completed: %s (agent=%s)", task.task_id, result.status, agent.agent_id)
 
         except Exception as e:
             logger.exception("Task %s failed with exception", task.task_id)
-            await reporter.report_complete(task.task_id, TaskResult(
+            await report_task_complete(TaskResult(
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=str(e),
                 execution_attempt_id=task.execution_attempt_id,
@@ -15394,7 +15622,9 @@ class RuntimeDaemon:
         for conn in self.connections:
             await conn.stop()
 
-        _clear_local_runtime_registration_snapshot(self._local_runtime_instance_id)
+        if not getattr(self, "_desktop_restart_requested", False):
+            _clear_local_runtime_registration_snapshot(self._local_runtime_instance_id)
+        _clear_desktop_daemon_restart_request(self._local_runtime_instance_id)
         logger.info("Daemon stopped.")
 
     def handle_signal(self, sig):

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/forgexa_cli/main.py

@@ -79,6 +79,8 @@ except ImportError:
 
 # Module-level override applied by main() when --server-url is passed.
 _SERVER_URL_OVERRIDE: str | None = None
+_OFFICIAL_PYPI_BASE_URL = "https://pypi.org"
+_OFFICIAL_PYPI_SIMPLE_INDEX_URL = f"{_OFFICIAL_PYPI_BASE_URL}/simple"
 
 
 # ── Banner ────────────────────────────────────────────────────────────────────
@@ -924,9 +926,22 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
                 "Use `pipx upgrade forgexa-cli` manually after restoring your pipx installation."
             )
         if target_version:
-            command = [pipx, "install", "--force", _package_spec_for_version(target_version)]
+            command = [
+                pipx,
+                "install",
+                "--force",
+                "--index-url",
+                _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+                _package_spec_for_version(target_version),
+            ]
         else:
-            command = [pipx, "upgrade", "forgexa-cli"]
+            command = [
+                pipx,
+                "upgrade",
+                "--index-url",
+                _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+                "forgexa-cli",
+            ]
         return UpgradePlan(
             installer="pipx",
             command=command,
@@ -940,7 +955,15 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
             "Reinstall forgexa-cli with pipx or a Python environment that includes pip."
         )
 
-    command = [python, "-m", "pip", "install", "--upgrade"]
+    command = [
+        python,
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "--index-url",
+        _OFFICIAL_PYPI_SIMPLE_INDEX_URL,
+    ]
     if _is_user_site_install(dist_root) and not _is_virtualenv():
         command.append("--user")
     if _is_pep668_environment():
@@ -1023,7 +1046,7 @@ def _latest_published_cli_version() -> str:
         import httpx
 
         with httpx.Client(timeout=5) as client:
-            response = client.get("https://pypi.org/pypi/forgexa-cli/json")
+            response = client.get(f"{_OFFICIAL_PYPI_BASE_URL}/pypi/forgexa-cli/json")
             response.raise_for_status()
             version = _normalize_target_version(str(response.json()["info"]["version"]))
     except Exception as exc:

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.3
+Version: 1.47.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT
@@ -132,10 +132,16 @@ forgexa upgrade --target-version 1.12.3
 
 The command detects how `forgexa-cli` was installed:
 
-- `pipx` install: uses `pipx upgrade forgexa-cli`, or `pipx install --force forgexa-cli==<version>` for a pinned version
-- `pip` install: uses `python -m pip install --upgrade forgexa-cli`
+- `pipx` install: uses `pipx upgrade --index-url https://pypi.org/simple forgexa-cli`, or `pipx install --force --index-url https://pypi.org/simple forgexa-cli==<version>` for a pinned version
+- `pip` install: uses `python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli`
 - non-editable local path install (`pip install /path/to/cli`): follows the same `pip` upgrade path and switches to the published PyPI release
 
+Self-upgrades pass `--index-url https://pypi.org/simple` to pip or pipx, matching the official PyPI release check and avoiding a configured mirror that has not yet synchronized a new release. A direct `pip install --upgrade forgexa-cli` command always follows that Python environment's pip configuration. When its mirror is behind, upgrade manually with:
+
+```bash
+python -m pip install --upgrade --index-url https://pypi.org/simple forgexa-cli==1.12.3
+```
+
 For safety, `forgexa upgrade` stops any running local daemon before upgrading. If the daemon was previously started in background mode, the CLI starts it again automatically after a successful upgrade; otherwise it prints a manual restart hint.
 
 `forgexa upgrade` supports standard PyPI / pipx installs and non-editable local path installs. Editable installs, VCS installs, and other direct URL installs are rejected with a manual upgrade hint.

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/pyproject.toml

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

{forgexa_cli-1.47.3 → forgexa_cli-1.47.4}/tests/test_auth_and_runtime_commands.py

@@ -575,7 +575,13 @@ def test_build_upgrade_plan_for_pipx_latest(monkeypatch: pytest.MonkeyPatch) ->
     plan = main._build_upgrade_plan(None)
 
     assert plan.installer == "pipx"
-    assert plan.command == ["/usr/local/bin/pipx", "upgrade", "forgexa-cli"]
+    assert plan.command == [
+        "/usr/local/bin/pipx",
+        "upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
+        "forgexa-cli",
+    ]
 
 
 def test_build_upgrade_plan_for_pipx_pinned_version(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -589,7 +595,14 @@ def test_build_upgrade_plan_for_pipx_pinned_version(monkeypatch: pytest.MonkeyPa
     plan = main._build_upgrade_plan("1.12.3")
 
     assert plan.installer == "pipx"
-    assert plan.command == ["/usr/local/bin/pipx", "install", "--force", "forgexa-cli==1.12.3"]
+    assert plan.command == [
+        "/usr/local/bin/pipx",
+        "install",
+        "--force",
+        "--index-url",
+        "https://pypi.org/simple",
+        "forgexa-cli==1.12.3",
+    ]
 
 
 def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -613,6 +626,8 @@ def test_build_upgrade_plan_for_pip_user_site(monkeypatch: pytest.MonkeyPatch) -
         "pip",
         "install",
         "--upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
         "--user",
         "forgexa-cli==1.12.3",
     ]
@@ -634,6 +649,8 @@ def test_build_upgrade_plan_adds_break_system_packages_on_pep668(monkeypatch: py
 
     assert "--break-system-packages" in plan.command
     assert "--user" in plan.command
+    assert "--index-url" in plan.command
+    assert plan.command[plan.command.index("--index-url") + 1] == "https://pypi.org/simple"
     assert plan.command[-1] == "forgexa-cli"
 
 
@@ -666,6 +683,8 @@ def test_build_upgrade_plan_allows_non_editable_local_path_installs(monkeypatch:
         "pip",
         "install",
         "--upgrade",
+        "--index-url",
+        "https://pypi.org/simple",
         "--user",
         "--break-system-packages",
         "forgexa-cli",