forgexa-cli 1.18.12__tar.gz → 1.19.0__tar.gz

{forgexa_cli-1.18.12 → forgexa_cli-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.18.12
+Version: 1.19.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.18.12 → forgexa_cli-1.19.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.18.12 → forgexa_cli-1.19.0}/forgexa_cli/daemon.py

@@ -555,7 +555,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.18.12"
+DAEMON_VERSION = "1.19.0"
 
 
 def _detect_client_type() -> str:
@@ -3520,16 +3520,20 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
 
 
 class _IdleTimeoutError(asyncio.TimeoutError):
-    """Raised when an agent process produces no stdout for longer than AGENT_IDLE_TIMEOUT.
+    """Raised when an agent produces no observable activity for AGENT_IDLE_TIMEOUT.
 
     Subclasses asyncio.TimeoutError so existing ``except asyncio.TimeoutError``
     handlers catch it, but callers can distinguish it from an absolute wall-clock
     timeout via ``isinstance(exc, _IdleTimeoutError)`` or ``exc.idle_seconds``.
+    Partial output is attached before propagation so the failure report retains
+    the evidence needed to diagnose the blocked operation.
     """
 
     def __init__(self, idle_seconds: float) -> None:
         super().__init__(f"idle:{idle_seconds:.0f}s")
         self.idle_seconds = idle_seconds
+        self.stdout = ""
+        self.stderr = ""
 
 
 def _workspace_has_recent_activity(
@@ -4202,13 +4206,15 @@ class ProcessManager:
           not killed while actively producing output.
         - on_chunk(lines) is called with each decoded line so the caller can
           forward to the progress reporter without waiting for completion.
-        - Idle timeout: if the agent produces no stdout for AGENT_IDLE_TIMEOUT
-          seconds the code checks for filesystem activity in workspace_path
+        - Idle timeout: if the agent produces no stdout or stderr bytes for
+          AGENT_IDLE_TIMEOUT seconds the code checks for filesystem activity in
+          workspace_path
           before deciding to kill.  If files were recently modified the agent
           is doing silent work (npm install, compilation, test runs, etc.) and
-          the idle timer is reset.  Only when BOTH stdout AND the filesystem
-          are idle does the process get killed.  This eliminates false-positive
-          kills at the idle boundary.
+          the idle timer is reset.  Only when output and the filesystem are
+          idle does the process get killed. Reading byte chunks rather than
+          lines is important: JSON and progress streams are not guaranteed to
+          flush a newline while the agent is working.
         - Absolute timeout (``timeout`` param): hard ceiling for zombie-process
           prevention.  Always kills at this boundary (no extension), but logs
           filesystem activity status for post-mortem observability.
@@ -4227,38 +4233,42 @@ class ProcessManager:
                 pass
             proc.stdin.close()
 
-        stdout_lines: list[str] = []
+        stdout_chunks: list[bytes] = []
         stderr_chunks: list[bytes] = []
 
         async def _read_stderr():
             if not proc.stderr:
                 return
-            if stream_stderr:
-                # Agent (e.g. Kimi Code 0.18.0+) writes real-time progress to
-                # stderr.  Read line-by-line and forward to on_chunk so the
-                # user sees output immediately.  Also reset the idle timer so
-                # the agent is not killed while actively working on stderr.
-                while True:
-                    line_bytes = await proc.stderr.readline()
-                    if not line_bytes:
-                        break
-                    stderr_chunks.append(line_bytes)
-                    line = line_bytes.decode(errors="replace").rstrip("\n")
-                    if line:
-                        _last_activity_at[0] = time.monotonic()
-                        stdout_lines.append(line)
-                        if on_chunk:
+            pending_line = ""
+            while True:
+                data = await proc.stderr.read(4096)
+                if not data:
+                    break
+                # Stderr often contains startup, authentication, and transport
+                # progress. It is an activity signal even when it is not shown
+                # in the live execution panel.
+                _last_activity_at[0] = time.monotonic()
+                stderr_chunks.append(data)
+                if stream_stderr:
+                    pending_line += data.decode(errors="replace")
+                    complete, separator, pending_line = pending_line.rpartition("\n")
+                    if separator and complete:
+                        lines = [line for line in complete.split("\n") if line]
+                        if lines and on_chunk:
                             try:
-                                await on_chunk([line])
+                                await on_chunk(lines)
                             except Exception:
                                 pass
-            else:
-                data = await proc.stderr.read()
-                stderr_chunks.append(data)
+            if stream_stderr and pending_line and on_chunk:
+                try:
+                    await on_chunk([pending_line])
+                except Exception:
+                    pass
 
         async def _read_stdout():
             if not proc.stdout:
                 return
+            pending_line = ""
             while True:
                 # ── Timeout checks ────────────────────────────────────────────
                 now = time.monotonic()
@@ -4304,7 +4314,7 @@ class ProcessManager:
                     else:
                         # No stdout AND no filesystem activity → truly hung.
                         logger.warning(
-                            "Task %s agent idle %.0fs — no stdout, no "
+                            "Task %s agent idle %.0fs — no output, no "
                             "filesystem activity; killing hung process",
                             task_id, idle_elapsed,
                         )
@@ -4319,17 +4329,17 @@ class ProcessManager:
                     30.0,
                 )
 
-                # ── Read one line with a bounded wait ─────────────────────────
+                # ── Read available bytes with a bounded wait ───────────────────
                 try:
-                    line_bytes = await asyncio.wait_for(
-                        proc.stdout.readline(), timeout=check_interval
+                    data = await asyncio.wait_for(
+                        proc.stdout.read(4096), timeout=check_interval
                     )
                 except asyncio.TimeoutError:
-                    # readline timed out within check_interval — no new output
-                    # yet.  Loop back to re-evaluate idle/absolute conditions.
+                    # No new output yet. Loop back to re-evaluate idle/absolute
+                    # conditions.
                     continue
                 except (ValueError, asyncio.LimitOverrunError, Exception) as exc:
-                    # Line exceeded stream buffer limit — drain remaining bulk.
+                    # Stream read error — drain remaining bulk.
                     logger.warning(
                         "Stream read error for task %s (%s: %s), draining remaining output",
                         task_id, type(exc).__name__, exc,
@@ -4339,28 +4349,27 @@ class ProcessManager:
                     except Exception:
                         remaining = b""
                     if remaining:
-                        for chunk_line in remaining.decode(errors="replace").split("\n"):
-                            if chunk_line:
-                                stdout_lines.append(chunk_line)
-                                if on_chunk:
-                                    try:
-                                        await on_chunk([chunk_line])
-                                    except Exception:
-                                        pass
+                        stdout_chunks.append(remaining)
                     break
 
-                if not line_bytes:
+                if not data:
                     break  # EOF — process exited normally
 
                 # ── New output received — reset idle timer ────────────────────
                 _last_activity_at[0] = time.monotonic()
-                line = line_bytes.decode(errors="replace").rstrip("\n")
-                stdout_lines.append(line)
-                if on_chunk:
+                stdout_chunks.append(data)
+                pending_line += data.decode(errors="replace")
+                complete, separator, pending_line = pending_line.rpartition("\n")
+                if separator and complete and on_chunk:
                     try:
-                        await on_chunk([line])
+                        await on_chunk([line for line in complete.split("\n") if line])
                     except Exception:
                         pass  # never let on_chunk crash the agent run
+            if pending_line and on_chunk:
+                try:
+                    await on_chunk([pending_line])
+                except Exception:
+                    pass
 
         try:
             # Outer wait_for uses timeout+idle_timeout as generous safety net.
@@ -4376,18 +4385,23 @@ class ProcessManager:
             _kill_proc(proc)
             # Drain any remaining output after kill
             try:
-                remaining, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                remaining, remaining_stderr = await asyncio.wait_for(proc.communicate(), timeout=5)
                 if remaining:
-                    for line in remaining.decode(errors="replace").split("\n"):
-                        if line:
-                            stdout_lines.append(line)
+                    stdout_chunks.append(remaining)
+                if remaining_stderr:
+                    stderr_chunks.append(remaining_stderr)
             except Exception:
                 pass
+            if isinstance(_exc, _IdleTimeoutError):
+                _exc.stdout = b"".join(stdout_chunks).decode(errors="replace")
+                _exc.stderr = b"".join(stderr_chunks).decode(errors="replace")
             raise  # re-raise (_IdleTimeoutError preserves subclass type)
 
         await proc.wait()
-        stdout = "\n".join(stdout_lines)
-        stderr = (stderr_chunks[0] if stderr_chunks else b"").decode(errors="replace")
+        stdout = b"".join(stdout_chunks).decode(errors="replace")
+        stderr = b"".join(stderr_chunks).decode(errors="replace")
+        if stream_stderr and stderr:
+            stdout = "\n".join(part for part in (stdout, stderr) if part)
         return stdout, stderr, proc.returncode or 0
 
     async def _run_claude(
@@ -4515,10 +4529,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("Claude stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -5314,10 +5335,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("Copilot stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -5383,10 +5411,17 @@ class ProcessManager:
         except asyncio.TimeoutError as exc:
             _kill_proc(self.active_processes.pop(task_id, None) or proc)
             _err = (
-                f"Agent idle for {exc.idle_seconds:.0f}s without output — process terminated. "
-                "Task may require more context decomposition or a different agent."
+                f"Agent produced no stdout, stderr, or workspace changes for "
+                f"{exc.idle_seconds:.0f}s — process terminated. Inspect retained "
+                "output and the daemon log for the blocked operation."
             ) if isinstance(exc, _IdleTimeoutError) else f"Timed out after {timeout}s (absolute limit)"
-            return TaskResult(status="failed", exit_code=-1, stdout="", stderr="", error=_err)
+            return TaskResult(
+                status="failed",
+                exit_code=-1,
+                stdout=getattr(exc, "stdout", "")[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                stderr=getattr(exc, "stderr", "")[-10000:],
+                error=_err,
+            )
         except Exception as exc:
             logger.exception("CLI stream error for task %s", task_id)
             if task_id in self.active_processes:
@@ -9213,7 +9248,19 @@ class RuntimeDaemon:
         workspace_path: Path,
         *diff_args: str,
     ) -> str | None:
-        """Reject Git changes that alter only file modes, not file contents."""
+        """Detect Git changes that alter only a file's mode, not its content.
+
+        Every Forgexa-managed workspace is configured with
+        ``core.filemode=false`` (see ``_prepare_workspace``), which makes Git
+        ignore on-disk executable-bit drift entirely for ``git status``/
+        ``git diff``/``git add`` — incidental permission noise from
+        checkouts, worktree creation, or file-rewrite tools can never reach
+        the diff/index we inspect here. The ONLY way a mode-only change can
+        appear is a deliberate ``git update-index --chmod=...`` (e.g. an
+        agent restoring a shell script's executable bit that a prior commit
+        lost). That is legitimate, intentional work — not noise — so it
+        must be allowed to commit; we only log it for audit visibility.
+        """
         proc = await asyncio.create_subprocess_exec(
             "git", "diff", "--raw", "--no-abbrev", "--no-renames", "-z", *diff_args,
             cwd=str(workspace_path),
@@ -9240,17 +9287,18 @@ class RuntimeDaemon:
             if old_object == new_object and old_mode != new_mode:
                 mode_only_paths.append(path)
 
-        if not mode_only_paths:
-            return None
+        if mode_only_paths:
+            sample = ", ".join(mode_only_paths[:5])
+            remainder = "" if len(mode_only_paths) <= 5 else ", ..."
+            logger.info(
+                "Auto-commit includes %d permission-only file change(s) with "
+                "unchanged content (%s%s) — allowing (core.filemode=false means "
+                "this can only come from a deliberate executable-bit fix, not "
+                "incidental noise).",
+                len(mode_only_paths), sample, remainder,
+            )
 
-        sample = ", ".join(mode_only_paths[:5])
-        remainder = "" if len(mode_only_paths) <= 5 else ", ..."
-        return (
-            "Auto-commit blocked: detected "
-            f"{len(mode_only_paths)} permission-only file change(s) with unchanged content "
-            f"({sample}{remainder}). Restore the original modes before retrying; "
-            "Forgexa does not auto-commit permission-only changes."
-        )
+        return None
 
     async def _auto_commit(
         self,

{forgexa_cli-1.18.12 → forgexa_cli-1.19.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.18.12
+Version: 1.19.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.18.12 → forgexa_cli-1.19.0}/pyproject.toml

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