forgexa-cli 1.57.6__tar.gz → 1.58.0__tar.gz

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.57.6
+Version: 1.58.0
 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

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/forgexa_cli/agent_core.py

@@ -877,6 +877,8 @@ class AgentDiscovery:
         "binary found but not functional".
         """
         import re
+        probe_dir = None
+        proc = None
         try:
             parts = detect_cmd.split()
             if executable:
@@ -886,11 +888,17 @@ class AgentDiscovery:
                 if resolved:
                     parts[0] = resolved
             parts = _prepare_agent_command(parts, preserve_argv=False)
+            env = None
+            if detect_cmd in ("opencode --version", "mimo --version"):
+                probe_dir = tempfile.TemporaryDirectory(prefix=f"forgexa-{detect_cmd.split()[0]}-probe-")
+                env = os.environ.copy()
+                env.update(TMPDIR=probe_dir.name, BUN_TMPDIR=probe_dir.name)
             proc = await asyncio.create_subprocess_exec(
                 *parts,
                 stdin=asyncio.subprocess.DEVNULL,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
+                env=env,
                 **_agent_process_group_kwargs(),
             )
             stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=10)
@@ -918,11 +926,19 @@ class AgentDiscovery:
                 )
                 return None
             return output
+        except asyncio.CancelledError:
+            raise
         except Exception as exc:
             logger.warning(
                 "Version check for %r raised %s: %s", detect_cmd, type(exc).__name__, exc,
             )
             return None
+        finally:
+            if proc is not None and proc.returncode is None:
+                _kill_proc(proc)
+                await proc.wait()
+            if probe_dir is not None:
+                probe_dir.cleanup()
 
     @staticmethod
     async def _probe_bwrap_support() -> None:

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/forgexa_cli/daemon.py

@@ -1150,7 +1150,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.57.6"
+DAEMON_VERSION = "1.58.0"
 
 
 def _detect_client_type() -> str:
@@ -2899,11 +2899,21 @@ class WorkspaceManager:
         self._ssh_keys[project_key] = ssh_private_key
 
     @staticmethod
-    def _summarize_git_error(error: Exception) -> str:
+    def _summarize_git_error(error: Exception, *, tail: bool = False) -> str:
         """Return a compact Git error without exposing embedded HTTPS credentials."""
         detail = " ".join(str(error).split())
         detail = re.sub(r"(https?://)[^/@\s]+@", r"\1***@", detail)
-        return detail[:500]
+        return detail[-500:] if tail else detail[:500]
+
+    @staticmethod
+    def _git_push_diagnostic(error: Exception) -> str:
+        detail = str(error).replace("\r\n", "\n").replace("\r", "\n")
+        detail = re.sub(r"(https?://)[^/@\s]+@", r"\1***@", detail)
+        if len(detail) <= 16_000:
+            return detail
+        beginning, ending = detail[:1000], detail[-14_800:]
+        omitted = len(detail) - len(beginning) - len(ending)
+        return f"{beginning}\n... [{omitted} earlier characters omitted] ...\n{ending}"
 
     def _migrate_legacy_project_dirs(self) -> None:
         """Move project directories from root/ to root/projects/ (one-time migration).
@@ -5507,6 +5517,10 @@ class _TaskAttachmentDownloadError(RuntimeError):
     """Raised when a required task attachment cannot be staged safely."""
 
 
+class _TaskAttachmentUnavailableError(_TaskAttachmentDownloadError):
+    """Raised when the attachment source is unavailable but the task can proceed."""
+
+
 def _workspace_has_recent_activity(
     workspace_path: "Path", since_monotonic: float, max_depth: int = 4
 ) -> bool:
@@ -5627,6 +5641,8 @@ class ProcessManager:
         "authentication required",
         "authenticate with the github",
         "gh auth login",
+        "your github token may be invalid",
+        "rejected the cli github credential",
     ]
 
     def __init__(self):
@@ -6693,6 +6709,7 @@ class ProcessManager:
                     data_home=tmp_data_root,
                     require_windows_shell=True,
                 )
+                env.update(TMPDIR=tmp_data_root, BUN_TMPDIR=tmp_data_root)
             except RuntimeError as exc:
                 return TaskResult(
                     status="failed",
@@ -6786,6 +6803,7 @@ class ProcessManager:
                 prompt_file=prompt_file,
             )
             env = agent_core.mimo_base_env(os.environ.copy())
+            env.update(TMPDIR=tmp_root, BUN_TMPDIR=tmp_root)
             result = await self._run_cli(
                 cmd, cwd, timeout, task_id, on_chunk=on_chunk, env=env,
             )
@@ -7640,6 +7658,59 @@ class ProcessManager:
                     return retry_result
                 _auth_state["persist"] = False
 
+            auth_detail = " ".join(
+                [*structured_errors, stderr]
+            ).lower()
+            token_auth_error = (
+                "your github token may be invalid" in auth_detail
+                or "rejected the cli github credential" in auth_detail
+            )
+            if token_auth_error and not (copilot_exit == 0 and returncode == 0):
+                _auth_state["persist"] = False
+            if (
+                token_auth_error
+                and not (copilot_exit == 0 and returncode == 0)
+                and not signals["has_meaningful_content"]
+                and not self._copilot_called_any_tools(stdout)
+            ):
+                recovery_home = (
+                    Path(_master_copilot_home)
+                    if auth_env_var and _master_copilot_home
+                    else agent_core.copilot_recovery_home(_isolated_copilot_home)
+                )
+                if (
+                    not _retry_without_token_env
+                    and recovery_home
+                    and (recovery_home / "config.json").is_file()
+                ):
+                    restored = await asyncio.to_thread(
+                        agent_core.replace_copilot_auth_state,
+                        recovery_home,
+                        _isolated_copilot_home,
+                    )
+                    can_retry_with_login = bool(auth_env_var or restored)
+                else:
+                    can_retry_with_login = False
+                if can_retry_with_login:
+                    logger.warning(
+                        "Copilot token authentication failed before work for task %s; "
+                        "retrying once with stored login and token environment variables removed",
+                        task_id,
+                    )
+                    retry_result = 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=_retry_without_effort,
+                        _retry_without_token_env=True,
+                        _isolated_copilot_home=_isolated_copilot_home,
+                        _auth_state=_auth_state,
+                    )
+                    _auth_state["persist"] = retry_result.status == "success"
+                    retry_result.metrics["copilot_auth_recovery"] = True
+                    return retry_result
+                _auth_state["persist"] = False
+
             if copilot_exit == 0 and returncode == 0:
                 return TaskResult(
                     status="success",
@@ -7737,6 +7808,12 @@ class ProcessManager:
                     failure_error = f"Copilot exited with code {effective_rc}: {stderr[-500:].strip()}"
                 else:
                     failure_error = f"Copilot exited with code {effective_rc}"
+                if token_auth_error:
+                    auth_source = auth_env_var or "stored Copilot login"
+                    failure_error = (
+                        f"Copilot authentication failed using {auth_source}. "
+                        f"{failure_error}"
+                    )
                 logger.error(
                     "Copilot task %s failed (process_rc=%s, result_exit=%s): %s",
                     task_id,
@@ -7835,6 +7912,7 @@ class ProcessManager:
         env: dict | None = None,
         stream_stderr: bool = False,
     ) -> TaskResult:
+        proc = None
         try:
             cmd = _prepare_agent_command(cmd)
             proc = await asyncio.create_subprocess_exec(
@@ -7873,7 +7951,8 @@ class ProcessManager:
                 failure_code="agent_launch_not_found",
             )
         except asyncio.TimeoutError as exc:
-            _kill_proc(self.active_processes.pop(task_id, None) or proc)
+            if proc is not None:
+                _kill_proc(proc)
             _err = (
                 f"Agent produced no stdout, stderr, or workspace changes for "
                 f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
@@ -7889,16 +7968,14 @@ class ProcessManager:
             )
         except Exception as exc:
             logger.exception("CLI stream error for task %s", task_id)
-            if task_id in self.active_processes:
-                try:
-                    self.active_processes[task_id].kill()
-                except Exception:
-                    pass
             return TaskResult(
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=f"Stream processing error: {exc}",
             )
         finally:
+            if proc is not None and proc.returncode is None:
+                _kill_proc(proc)
+                await proc.wait()
             self.active_processes.pop(task_id, None)
 
     def _parse_claude_output(self, stdout: str) -> dict:
@@ -10574,9 +10651,22 @@ class RuntimeDaemon:
                     timeout=httpx.Timeout(connect=10.0, read=30.0, write=10.0, pool=10.0),
                 ) as response:
                     if not 200 <= response.status_code < 300:
-                        raise _TaskAttachmentDownloadError(
-                            f"Attachment '{attachment_name}' download failed with HTTP {response.status_code}"
-                        )
+                        error = f"Attachment '{attachment_name}' download failed with HTTP {response.status_code}"
+                        if response.status_code in {409, 502}:
+                            await response.aread()
+                            try:
+                                detail = response.json()
+                            except ValueError:
+                                detail = None
+                            if isinstance(detail, dict) and detail.get("detail") == "Task attachment integrity check failed":
+                                raise _TaskAttachmentDownloadError(error)
+                            if response.status_code == 409 and isinstance(detail, dict) and detail.get("detail") == "Task attachment source no longer matches stored checksum":
+                                raise _TaskAttachmentUnavailableError(
+                                    f"Attachment '{attachment_name}' is unavailable: {detail['detail']}"
+                                )
+                        if response.status_code in {404, 502, 503, 504}:
+                            raise _TaskAttachmentUnavailableError(error)
+                        raise _TaskAttachmentDownloadError(error)
                     content_length = response.headers.get("content-length")
                     if content_length:
                         try:
@@ -10610,6 +10700,10 @@ class RuntimeDaemon:
                     temporary_path.replace(destination)
             except _TaskAttachmentDownloadError:
                 raise
+            except httpx.RequestError as exc:
+                raise _TaskAttachmentUnavailableError(
+                    f"Attachment '{attachment_name}' download failed ({type(exc).__name__})"
+                ) from exc
             except httpx.HTTPError as exc:
                 raise _TaskAttachmentDownloadError(
                     f"Attachment '{attachment_name}' download failed ({type(exc).__name__})"
@@ -10625,7 +10719,7 @@ class RuntimeDaemon:
                 timeout=timeout_seconds,
             )
         except asyncio.TimeoutError as exc:
-            raise _TaskAttachmentDownloadError(
+            raise _TaskAttachmentUnavailableError(
                 f"Attachment '{attachment_name}' download timed out after "
                 f"{timeout_seconds:.0f}s"
             ) from exc
@@ -10648,6 +10742,7 @@ class RuntimeDaemon:
 
         staging_dir = Path(tempfile.mkdtemp(prefix=f"forgexa-attachments-{task.task_id[:8]}-"))
         staged: list[tuple[str, list[str], str]] = []
+        unavailable: list[tuple[str, list[str], str]] = []
         deadline = time.monotonic() + self._TASK_ATTACHMENT_DOWNLOAD_TIMEOUT_SECONDS
         remaining_bytes = self._TASK_ATTACHMENT_MAX_TOTAL_BYTES
         try:
@@ -10676,12 +10771,6 @@ class RuntimeDaemon:
                     raise _TaskAttachmentDownloadError(
                         f"Attachment '{file_name}' cannot be staged securely because it has no artifact ID"
                     )
-                remaining_seconds = deadline - time.monotonic()
-                if remaining_seconds <= 0:
-                    raise _TaskAttachmentDownloadError(
-                        f"Task attachment staging timed out after "
-                        f"{self._TASK_ATTACHMENT_DOWNLOAD_TIMEOUT_SECONDS}s"
-                    )
                 if not conn.runtime_id:
                     raise _TaskAttachmentDownloadError(
                         f"Attachment '{file_name}' cannot be staged because this runtime is not registered"
@@ -10690,16 +10779,27 @@ class RuntimeDaemon:
                     f"{conn.server_url.rstrip('/')}/api/v1/runtimes/{conn.runtime_id}/"
                     f"tasks/{task.task_id}/attachments/{artifact_id}"
                 )
-                await self._download_task_attachment(
-                    conn.client,
-                    source_url,
-                    destination,
-                    attachment_name=file_name,
-                    expected_size=expected_size or None,
-                    expected_checksum=str(attachment.get("checksum") or ""),
-                    max_bytes=min(self._TASK_ATTACHMENT_MAX_BYTES, remaining_bytes),
-                    timeout_seconds=remaining_seconds,
-                )
+                try:
+                    remaining_seconds = deadline - time.monotonic()
+                    if remaining_seconds <= 0:
+                        raise _TaskAttachmentUnavailableError(
+                            f"Task attachment staging timed out after "
+                            f"{self._TASK_ATTACHMENT_DOWNLOAD_TIMEOUT_SECONDS}s"
+                        )
+                    await self._download_task_attachment(
+                        conn.client,
+                        source_url,
+                        destination,
+                        attachment_name=file_name,
+                        expected_size=expected_size or None,
+                        expected_checksum=str(attachment.get("checksum") or ""),
+                        max_bytes=min(self._TASK_ATTACHMENT_MAX_BYTES, remaining_bytes),
+                        timeout_seconds=remaining_seconds,
+                    )
+                except _TaskAttachmentUnavailableError as exc:
+                    logger.warning("Task %s attachment unavailable: %s", task.task_id, exc)
+                    unavailable.append((file_name, download_url_aliases, str(exc)))
+                    continue
                 remaining_bytes -= destination.stat().st_size
                 staged.append((file_name, download_url_aliases, str(destination)))
         except Exception:
@@ -10707,10 +10807,29 @@ class RuntimeDaemon:
             raise
 
         task.input_prompt = self._rewrite_staged_attachment_references(task.input_prompt, staged)
+        if unavailable:
+            notices = []
+            for file_name, download_urls, error in unavailable:
+                notices.append(f"- `{file_name}`: {error}")
+                for download_url in download_urls:
+                    command_pattern = r"`curl -L '" + re.escape(download_url) + r"' -o /tmp/[^`]+`"
+                    task.input_prompt = re.sub(command_pattern, "[attachment unavailable]", task.input_prompt)
+                    task.input_prompt = task.input_prompt.replace(f"Download: {download_url}", "Attachment unavailable")
+                    task.input_prompt = task.input_prompt.replace(download_url, "[attachment unavailable]")
+            task.input_prompt = "\n".join([
+                "## Unavailable Attachments",
+                "These files could not be retrieved. Continue with available inputs and report any missing evidence; do not retry their download URLs.",
+                *notices,
+                "",
+                task.input_prompt,
+            ])
         input_data = dict(task.input_data or {})
         input_data["prompt"] = task.input_prompt
         task.input_data = input_data
         logger.info("Prepared %d attachment(s) for task %s", len(staged), task.task_id)
+        if not staged:
+            shutil.rmtree(staging_dir, ignore_errors=True)
+            return None
         return staging_dir
 
     @staticmethod
@@ -17608,6 +17727,41 @@ class RuntimeDaemon:
 
                     if remote_ahead:
                         remote_count = len(remote_ahead.splitlines())
+                        if (
+                            task is not None
+                            and task.workspace_resolution == "cloud_worktree"
+                            and task.node_type == "analysis"
+                            and task.input_data.get("analysis_mode") == "fresh"
+                            and task.requirement_key
+                            and branch == f"feature/{task.requirement_key}"
+                        ):
+                            default_branch = task.project.get("default_branch") or "main"
+                            try:
+                                await git(
+                                    "merge-base", "--is-ancestor", f"origin/{default_branch}",
+                                    "HEAD", cwd=workspace_path,
+                                )
+                                if await self.workspace_manager._branch_has_impl_commits(
+                                    workspace_path, branch, default_branch,
+                                ):
+                                    return (
+                                        f"Push blocked: remote branch '{branch}' contains "
+                                        "implementation commits; fresh analysis cannot replace it."
+                                    )
+                                remote_sha = (await git(
+                                    "rev-parse", "--verify", f"refs/remotes/origin/{branch}",
+                                    cwd=workspace_path,
+                                )).strip()
+                                await git(
+                                    "push", f"--force-with-lease=refs/heads/{branch}:{remote_sha}",
+                                    "-u", "origin", branch, cwd=workspace_path,
+                                    project_key=project_key, timeout=settings.GIT_PUSH_TIMEOUT,
+                                )
+                                logger.info("Pushed fresh analysis branch %s with exact lease", branch)
+                                return None
+                            except RuntimeError as exc:
+                                detail = self.workspace_manager._git_push_diagnostic(exc)
+                                return f"Fresh analysis push blocked for branch '{branch}': {detail}"
                         # Divergence detected — but this is expected after rebase.
                         # Check if the remote commits are already incorporated
                         # (i.e., their patches are empty against our branch, meaning
@@ -17815,8 +17969,8 @@ class RuntimeDaemon:
                                         f"Push refused: remote branch '{branch}' has {remote_count} "
                                         f"commit(s) not in local history, rebase (-X theirs) failed, "
                                         f"and force-with-lease fallback also failed. "
-                                        f"Rebase error: {rebase_exc_str[:200]} | "
-                                        f"Force error: {force_exc_str[:200]}"
+                                        f"Rebase error:\n{self.workspace_manager._git_push_diagnostic(rebase_exc)}\n"
+                                        f"Force error:\n{self.workspace_manager._git_push_diagnostic(force_exc)}"
                                     )
 
                     logger.info("Found unpushed commits on %s, pushing...", branch)

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.57.6
+Version: 1.58.0
 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

{forgexa_cli-1.57.6 → forgexa_cli-1.58.0}/pyproject.toml

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