forgexa-cli 1.64.0__tar.gz → 1.65.0__tar.gz

{forgexa_cli-1.64.0 → forgexa_cli-1.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.64.0
+Version: 1.65.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.64.0 → forgexa_cli-1.65.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.64.0 → forgexa_cli-1.65.0}/forgexa_cli/daemon.py

@@ -133,6 +133,9 @@ _MANAGED_WSL_POLICY = getattr(_wsl_policy_module, "ACTIVE_POLICY", None)
 async def _create_subprocess_exec(*command, **kwargs):
     if _MANAGED_WSL_POLICY is not None:
         return await _MANAGED_WSL_POLICY.spawn(*command, **kwargs)
+    # Desktop stdin is its parent-liveness control pipe, never child input.
+    # Agent callers that need prompt input explicitly pass subprocess.PIPE.
+    kwargs.setdefault("stdin", asyncio.subprocess.DEVNULL)
     return await asyncio.create_subprocess_exec(*command, **kwargs)
 
 
@@ -1231,7 +1234,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.64.0"
+DAEMON_VERSION = "1.65.0"
 
 
 def _detect_client_type() -> str:
@@ -2767,6 +2770,27 @@ def _normalize_repo_identity(repo_url: str) -> str | None:
     return f"{host}/{path}"
 
 
+_LOCAL_BINDING_GIT_CLEANUP_TIMEOUT_SECONDS = 2.0
+_LOCAL_BINDING_VERIFICATION_TIMEOUT_SECONDS = 25.0
+_LOCAL_BINDING_VERIFICATION_CONCURRENCY = 4
+
+
+async def _stop_local_binding_git_probe(proc) -> None:
+    """Bound cleanup of this read-only probe, including Windows pipe teardown."""
+    try:
+        proc.kill()
+    except ProcessLookupError:
+        pass
+    except OSError as exc:
+        logger.warning("Local workspace Git probe termination failed (%s)", type(exc).__name__)
+    try:
+        # wait() can remain pending after Windows process exit until its pipe
+        # transport closes. Drain it, but never wait indefinitely for cleanup.
+        await asyncio.wait_for(proc.communicate(), timeout=_LOCAL_BINDING_GIT_CLEANUP_TIMEOUT_SECONDS)
+    except (asyncio.TimeoutError, OSError) as exc:
+        logger.warning("Local workspace Git probe cleanup did not complete (%s)", type(exc).__name__)
+
+
 async def _validate_local_workspace_binding(binding: dict[str, Any], runtime_id: str) -> str | None:
     if _MANAGED_WSL_POLICY is not None:
         _MANAGED_WSL_POLICY.check_mapping()
@@ -2803,6 +2827,7 @@ async def _validate_local_workspace_binding(binding: dict[str, Any], runtime_id:
         proc = await _create_subprocess_exec(
             _resolve_git_command() if _MANAGED_WSL_POLICY is not None else "git", "remote", "get-url", "origin",
             cwd=str(local_path),
+            stdin=asyncio.subprocess.DEVNULL,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.DEVNULL,
             **_agent_process_group_kwargs(),
@@ -2810,10 +2835,15 @@ async def _validate_local_workspace_binding(binding: dict[str, Any], runtime_id:
         stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
     except asyncio.TimeoutError:
         if proc is not None:
-            proc.kill()
-            await proc.wait()
+            await _stop_local_binding_git_probe(proc)
         return "remote_unreadable"
+    except asyncio.CancelledError:
+        if proc is not None:
+            await _stop_local_binding_git_probe(proc)
+        raise
     except OSError:
+        if proc is not None:
+            await _stop_local_binding_git_probe(proc)
         return "remote_unreadable"
     if proc.returncode != 0:
         return "remote_unreadable"
@@ -9067,6 +9097,8 @@ class HeartbeatService:
         self.daemon_id = daemon_id
         self.interval = interval
         self._task: asyncio.Task | None = None
+        self._verification_task: asyncio.Task | None = None
+        self._verification_requested: asyncio.Event | None = None
         self._active_tasks = 0
         self._agents: list[dict] = []
         self._preflight_snapshot_provider = preflight_snapshot_provider or (lambda: None)
@@ -9081,10 +9113,10 @@ class HeartbeatService:
         if _MANAGED_WSL_POLICY is not None and _MANAGED_WSL_POLICY.task is not None:
             return  # The task already retains mapping admission and the physical lock.
         try:
-            response = await self.client.get(
+            response = await asyncio.wait_for(self.client.get(
                 f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/local-workspace-bindings/verification",
                 timeout=10,
-            )
+            ), timeout=10)
             if response.status_code != 200:
                 detail = _safe_http_error_detail(response)
                 logger.warning(
@@ -9096,40 +9128,78 @@ class HeartbeatService:
             bindings = response.json()
             if not isinstance(bindings, list):
                 return
-            for binding in bindings:
-                if not isinstance(binding, dict) or not binding.get("id"):
-                    continue
-                if _MANAGED_WSL_POLICY is not None:
-                    await _MANAGED_WSL_POLICY.sync_binding(self, binding)
-                    continue
-                failure_code = await _validate_local_workspace_binding(binding, self.runtime_id)
-                if failure_code is None and binding.get("status") == "active":
-                    continue
-                response = await self.client.post(
-                    f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/local-workspace-bindings/{binding['id']}/activate",
-                    json={"success": failure_code is None, "reason": failure_code},
-                    timeout=10,
-                )
-                if response.status_code != 200:
-                    detail = _safe_http_error_detail(response)
-                    logger.warning(
-                        "Local workspace binding verification update failed: %s%s",
-                        response.status_code,
-                        f" ({detail})" if detail else "",
-                    )
+            # Prioritize fresh bindings and isolate each Native validation. A
+            # slow/broken old directory must not starve another pending one.
+            bindings = sorted(
+                (binding for binding in bindings if isinstance(binding, dict) and binding.get("id")),
+                key=lambda binding: binding.get("status") != "pending",
+            )
+            limit = 1 if _MANAGED_WSL_POLICY is not None else _LOCAL_BINDING_VERIFICATION_CONCURRENCY
+            semaphore = asyncio.Semaphore(limit)
+
+            async def verify_one(binding):
+                async with semaphore:
+                    try:
+                        await asyncio.wait_for(
+                            self._verify_local_workspace_binding(binding),
+                            timeout=_LOCAL_BINDING_VERIFICATION_TIMEOUT_SECONDS,
+                        )
+                    except Exception as exc:
+                        # Local exceptions can contain paths; only their type
+                        # may enter the daemon log that is uploaded remotely.
+                        logger.warning("Local workspace binding verification failed (%s)", type(exc).__name__)
+
+            await asyncio.gather(*(verify_one(binding) for binding in bindings))
         except Exception as exc:
-            logger.warning("Local workspace binding verification failed: %s", exc)
+            logger.warning("Local workspace binding verification request failed (%s)", type(exc).__name__)
+
+    async def _verify_local_workspace_binding(self, binding: dict[str, Any]) -> None:
+        if _MANAGED_WSL_POLICY is not None:
+            await _MANAGED_WSL_POLICY.sync_binding(self, binding)
+            return
+        failure_code = await _validate_local_workspace_binding(binding, self.runtime_id)
+        if failure_code is None and binding.get("status") == "active":
+            return
+        response = await asyncio.wait_for(self.client.post(
+            f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/local-workspace-bindings/{binding['id']}/activate",
+            json={"success": failure_code is None, "reason": failure_code},
+            timeout=10,
+        ), timeout=10)
+        if response.status_code != 200:
+            detail = _safe_http_error_detail(response)
+            logger.warning(
+                "Local workspace binding verification update failed: %s%s",
+                response.status_code,
+                f" ({detail})" if detail else "",
+            )
 
     async def start(self):
+        if self._task is not None and not self._task.done():
+            return
+        self._verification_requested = asyncio.Event()
+        self._verification_task = asyncio.create_task(self._verification_loop())
         self._task = asyncio.create_task(self._loop())
 
     async def stop(self):
-        if self._task:
-            self._task.cancel()
+        tasks = [task for task in (self._task, self._verification_task) if task is not None]
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        self._task = self._verification_task = None
+        self._verification_requested = None
+
+    async def _verification_loop(self):
+        requested = self._verification_requested
+        if requested is None:
+            return
+        while True:
+            await requested.wait()
+            requested.clear()
             try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
+                await self._sync_local_workspace_bindings()
+            except Exception as exc:
+                logger.warning("Local workspace binding verification cycle failed (%s)", type(exc).__name__)
 
     async def _loop(self):
         while True:
@@ -9157,7 +9227,10 @@ class HeartbeatService:
                 )
                 if resp.status_code == 200:
                     self._on_success()
-                    await self._sync_local_workspace_bindings()
+                    # Verification has its own single-flight worker. Never
+                    # await local Git/activation on the heartbeat's lifetime.
+                    if self._verification_requested is not None:
+                        self._verification_requested.set()
                 elif resp.status_code in (401, 403):
                     logger.warning("Heartbeat auth failed: %s %s", resp.status_code, resp.text)
                     self._on_auth_failure()
@@ -18681,10 +18754,37 @@ class RuntimeDaemon:
             self._shutdown_event.set()
 
 
+def _start_desktop_parent_monitor(daemon, loop):
+    """Stop only an explicitly Desktop-owned daemon when its parent pipe closes."""
+    if sys.platform != "win32" or os.environ.pop("FORGEXA_DESKTOP_PARENT_PIPE", None) != "1":
+        return None
+    stream = sys.stdin
+    if stream is None:
+        raise RuntimeError("Desktop parent pipe is unavailable")
+    import threading
+
+    def monitor():
+        try:
+            while stream.read(1):
+                pass
+        except (OSError, ValueError):
+            pass
+        try:
+            # Capture the running loop here, not in this background thread.
+            loop.call_soon_threadsafe(daemon.handle_signal, signal.SIGTERM)
+        except RuntimeError:
+            pass  # The daemon has already closed its loop.
+
+    thread = threading.Thread(target=monitor, name="desktop-parent-pipe", daemon=True)
+    thread.start()
+    return thread
+
+
 async def main():
     daemon = RuntimeDaemon()
 
     loop = asyncio.get_event_loop()
+    _start_desktop_parent_monitor(daemon, loop)
     if sys.platform != "win32":
         for sig in (signal.SIGINT, signal.SIGTERM):
             loop.add_signal_handler(sig, daemon.handle_signal, sig)

{forgexa_cli-1.64.0 → forgexa_cli-1.65.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.64.0
+Version: 1.65.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.64.0 → forgexa_cli-1.65.0}/pyproject.toml

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