forgexa-cli 1.22.5__tar.gz → 1.22.6__tar.gz

{forgexa_cli-1.22.5 → forgexa_cli-1.22.6}/PKG-INFO

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

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

{forgexa_cli-1.22.5 → forgexa_cli-1.22.6}/forgexa_cli/daemon.py

@@ -29,6 +29,7 @@ if sys.version_info < (3, 9):
 
 import asyncio
 import base64
+import errno
 import hashlib
 import json
 import logging
@@ -555,7 +556,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.22.5"
+DAEMON_VERSION = "1.22.6"
 
 
 def _detect_client_type() -> str:
@@ -1948,6 +1949,66 @@ class AgentDiscovery:
             logger.warning("bwrap probe error: %s", exc)
 
 
+class _WorkspaceFileLock:
+    """Advisory lock shared by daemon processes using one workspace root."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self._handle: Any | None = None
+
+    async def acquire(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._handle = open(self.path, "a+b")
+        waiting = False
+
+        try:
+            if sys.platform == "win32":
+                self._handle.seek(0)
+                if not self._handle.read(1):
+                    self._handle.write(b"\0")
+                    self._handle.flush()
+
+            while True:
+                try:
+                    self._handle.seek(0)
+                    if sys.platform == "win32":
+                        import msvcrt
+
+                        msvcrt.locking(self._handle.fileno(), msvcrt.LK_NBLCK, 1)
+                    elif fcntl is not None:
+                        fcntl.flock(self._handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    else:
+                        raise RuntimeError("Workspace file locking is unavailable on this platform")
+                    return
+                except OSError as exc:
+                    if exc.errno not in (errno.EACCES, errno.EAGAIN):
+                        raise
+                    if not waiting:
+                        logger.info("Waiting for workspace lock at %s", self.path)
+                        waiting = True
+                    await asyncio.sleep(0.1)
+        except BaseException:
+            self.release()
+            raise
+
+    def release(self) -> None:
+        handle, self._handle = self._handle, None
+        if handle is None:
+            return
+        try:
+            handle.seek(0)
+            if sys.platform == "win32":
+                import msvcrt
+
+                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+            elif fcntl is not None:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        except OSError:
+            pass
+        finally:
+            handle.close()
+
+
 class WorkspaceManager:
     """Manages isolated workspaces per task using git worktrees."""
 
@@ -1966,6 +2027,32 @@ class WorkspaceManager:
 
         self._dirs_ready = False
 
+    @staticmethod
+    def _workspace_key(task: TaskInfo) -> str:
+        if task.requirement_workflow_id:
+            return re.sub(r"[^a-zA-Z0-9_-]", "_", task.requirement_workflow_id)
+        return re.sub(r"[^a-zA-Z0-9_-]", "_", str(task.graph_id))
+
+    async def _acquire_file_lock(self, lock_path: Path) -> _WorkspaceFileLock:
+        lock = _WorkspaceFileLock(lock_path)
+        await lock.acquire()
+        return lock
+
+    async def _acquire_project_worktree_lock(self, project_dir: Path) -> _WorkspaceFileLock:
+        return await self._acquire_file_lock(project_dir / ".forgexa-worktree.lock")
+
+    async def acquire_workspace_execution_lock(
+        self,
+        project: dict,
+        task: TaskInfo,
+    ) -> _WorkspaceFileLock:
+        self._ensure_dirs()
+        project_key = str(project.get("project_key") or "default")
+        project_dir = self.projects_root / project_key
+        return await self._acquire_file_lock(
+            project_dir / ".forgexa-workspace-locks" / f"{self._workspace_key(task)}.lock"
+        )
+
     def _ensure_dirs(self) -> None:
         """Lazy initialization of workspace directories.
 
@@ -2376,10 +2463,7 @@ class WorkspaceManager:
         # analysis, execution, and fix graphs for the same requirement share
         # one directory and git worktree (C-2 / D-1 workspace reuse).
         # Fall back to graph_id for backward compatibility.
-        if task.requirement_workflow_id:
-            workspace_key = re.sub(r"[^a-zA-Z0-9_-]", "_", task.requirement_workflow_id)
-        else:
-            workspace_key = re.sub(r"[^a-zA-Z0-9_-]", "_", str(task.graph_id))
+        workspace_key = self._workspace_key(task)
 
         # Use human-readable branch name feature/{requirement_key}
         # when requirement_key is available; fallback to feature/{workspace_key}
@@ -2554,7 +2638,13 @@ class WorkspaceManager:
             await self._git("config", "core.filemode", "false", cwd=ws_path)
             return ws_path
 
-    async def _is_healthy_worktree(self, ws_path: Path, main_repo: Path | None = None) -> bool:
+    async def _is_healthy_worktree(
+        self,
+        ws_path: Path,
+        main_repo: Path | None = None,
+        *,
+        require_unlocked: bool = False,
+    ) -> bool:
         """Check if a git worktree directory is a valid *linked* worktree.
 
         A linked git worktree has .git as a FILE containing a gitdir pointer to
@@ -2610,6 +2700,8 @@ class WorkspaceManager:
                         gitdir.resolve().relative_to(expected_wt_root)
                     except ValueError:
                         return False
+                if require_unlocked and (gitdir / "index.lock").exists():
+                    return False
                 return True
         except OSError:
             pass
@@ -2686,6 +2778,7 @@ class WorkspaceManager:
         branch_name: str,
         *,
         healthy_only: bool = True,
+        require_unlocked: bool = False,
     ) -> Path | None:
         """Return a linked worktree already on branch_name."""
         try:
@@ -2715,7 +2808,11 @@ class WorkspaceManager:
                 continue
             if not healthy_only:
                 return candidate_path
-            if candidate_path.exists() and await self._is_healthy_worktree(candidate_path, main_repo=main_repo):
+            if candidate_path.exists() and await self._is_healthy_worktree(
+                candidate_path,
+                main_repo=main_repo,
+                require_unlocked=require_unlocked,
+            ):
                 return candidate_path
 
         return None
@@ -3100,14 +3197,18 @@ class WorkspaceManager:
         # concurrent tasks from racing on _main (shutil.rmtree / git clone / worktree add).
         project_lock = await self._get_project_lock(project_dir)
         async with project_lock:
-            return await self._create_worktree_impl(
-                project_dir, repo_url, default_branch,
-                workspace_key, branch_name,
-                fresh_start=fresh_start,
-                project_key=project_key,
-                expect_branch=expect_branch,
-                detach_head=detach_head,
-            )
+            file_lock = await self._acquire_project_worktree_lock(project_dir)
+            try:
+                return await self._create_worktree_impl(
+                    project_dir, repo_url, default_branch,
+                    workspace_key, branch_name,
+                    fresh_start=fresh_start,
+                    project_key=project_key,
+                    expect_branch=expect_branch,
+                    detach_head=detach_head,
+                )
+            finally:
+                file_lock.release()
 
     async def _create_worktree_impl(
         self, project_dir: Path, repo_url: str, default_branch: str,
@@ -3130,7 +3231,11 @@ class WorkspaceManager:
         if ws_path.exists():
             # Validate that this worktree is healthy (its .git file points to a
             # valid main repo).  Worktrees break when directories are moved.
-            if not await self._is_healthy_worktree(ws_path, main_repo=main_repo):
+            if not await self._is_healthy_worktree(
+                ws_path,
+                main_repo=main_repo,
+                require_unlocked=fresh_start,
+            ):
                 logger.warning("Broken worktree detected at %s — removing and recreating", ws_path)
                 await self._remove_broken_worktree(main_repo, ws_path, workspace_key)
             else:
@@ -3605,6 +3710,19 @@ class WorkspaceManager:
         # that `git worktree add ... {default_branch}` uses latest code.
         # We fetch first, then update the local ref directly (avoids
         # needing to checkout default_branch which may conflict with worktrees).
+        try:
+            await self._git(
+                "fetch", "origin",
+                f"{default_branch}:refs/remotes/origin/{default_branch}",
+                cwd=main_repo,
+                timeout=settings.GIT_FETCH_TIMEOUT,
+                project_key=project_key,
+            )
+        except RuntimeError as exc:
+            raise RuntimeError(
+                f"Failed to fetch default branch '{default_branch}' from remote: {exc}"
+            ) from exc
+
         try:
             await self._git(
                 "update-ref", f"refs/heads/{default_branch}",
@@ -3815,7 +3933,7 @@ class WorkspaceManager:
             # feature ref behind. Attaching that ref would resurrect stale
             # requirement history, so reset it explicitly.
             existing_branch_worktree = await self._find_existing_worktree_for_branch(
-                main_repo, branch_name,
+                main_repo, branch_name, require_unlocked=True,
             )
             if existing_branch_worktree is not None:
                 logger.info(
@@ -3839,7 +3957,7 @@ class WorkspaceManager:
                 )
             except Exception as exc:
                 existing_branch_worktree = await self._find_existing_worktree_for_branch(
-                    main_repo, branch_name,
+                    main_repo, branch_name, require_unlocked=True,
                 )
                 if existing_branch_worktree is not None:
                     logger.info(
@@ -4087,6 +4205,13 @@ class WorkspaceManager:
         )
         try:
             stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        except asyncio.CancelledError:
+            _kill_proc(proc)
+            try:
+                await asyncio.shield(asyncio.wait_for(proc.wait(), timeout=5.0))
+            except Exception:
+                pass
+            raise
         except (TimeoutError, asyncio.TimeoutError):
             # Kill the entire process group so that SSH (and any other
             # child processes git may have spawned) are also terminated.
@@ -8601,6 +8726,7 @@ class RuntimeDaemon:
                 project_lock_key,
             )
         await project_lock.acquire()
+        workspace_execution_lock: _WorkspaceFileLock | None = None
         try:
             # 1. Find the right agent
             agent = self._select_agent(task.agent_type, task.fallback_chain)
@@ -8624,6 +8750,11 @@ class RuntimeDaemon:
                 ))
                 return
 
+            workspace_execution_lock = await self.workspace_manager.acquire_workspace_execution_lock(
+                task.project,
+                task,
+            )
+
             # Track which agents we've already tried (for rate-limit fallback)
             tried_agents: set[str] = set()
 
@@ -9362,6 +9493,8 @@ class RuntimeDaemon:
                 error=str(e),
             ))
         finally:
+            if workspace_execution_lock is not None:
+                workspace_execution_lock.release()
             project_lock.release()
 
     def _select_fallback_agent(
@@ -9876,6 +10009,7 @@ class RuntimeDaemon:
                 project_lock_key,
             )
         await project_lock.acquire()
+        workspace_execution_lock: _WorkspaceFileLock | None = None
 
         try:
             # Report progress: starting
@@ -9940,6 +10074,10 @@ class RuntimeDaemon:
                 workspace_source_mode=qa_ws_source.get("mode"),
                 workspace_branch=qa_ws_source.get("branch"),
             )
+            workspace_execution_lock = await self.workspace_manager.acquire_workspace_execution_lock(
+                project_info,
+                fake_task,
+            )
             workspace_path = await self.workspace_manager.prepare_workspace(
                 project_info, fake_task,
             )
@@ -10163,6 +10301,8 @@ class RuntimeDaemon:
             except Exception:
                 pass
         finally:
+            if workspace_execution_lock is not None:
+                workspace_execution_lock.release()
             project_lock.release()
 
     async def _collect_workspace_git_info(self, workspace_path: Path) -> dict:

{forgexa_cli-1.22.5 → forgexa_cli-1.22.6}/forgexa_cli.egg-info/PKG-INFO

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

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