forgexa-cli 1.59.0__tar.gz → 1.59.2__tar.gz

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/PKG-INFO

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

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

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/forgexa_cli/_local_bind.py

@@ -47,58 +47,34 @@ def save_local_workspaces_mapping(mapping: dict) -> None:
 
 
 @contextlib.contextmanager
-def local_workspaces_mapping_lock() -> Iterator[None]:
-    """Advisory cross-process lock for read-modify-write cycles on the
-    mapping file (multi-workspace parallel design §6.1/§6.3). Shares the
-    `local-workspaces.json.lock` path with the Desktop Rust writer (fd-lock
-    crate); without it, a CLI bind-local and a Desktop link running
-    concurrently could each drop the other's just-written entry. Best-effort:
-    platforms without fcntl/msvcrt degrade to lock-free (the atomic rename
-    still prevents torn files).
-    """
+def local_workspaces_mapping_lock(workspace_path: str | Path | None = None) -> Iterator[None]:
+    """Serialize mapping writes; lock or parse failures never degrade to unlocked writes."""
+    from forgexa_cli.agent_core import acquire_file_lock, release_file_lock
+
     path = local_workspaces_mapping_path()
     lock_path = path.with_name(path.name + ".lock")
+    lock_file = acquire_file_lock(lock_path, blocking=True)
+    if lock_file is None:
+        raise RuntimeError("Could not acquire the local workspace mapping write lock")
+    workspace_lock = None
     try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        lock_file = open(lock_path, "a+")
-    except OSError:
-        yield
-        return
-
-    lock_kind = None
-    try:
-        try:
-            import fcntl
-
-            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
-            lock_kind = "fcntl"
-        except ImportError:
+        if path.exists():
             try:
-                import msvcrt
-
-                lock_file.seek(0)
-                msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
-                lock_kind = "msvcrt"
-            except (ImportError, OSError):
-                pass
+                mapping = json.loads(path.read_text(encoding="utf-8"))
+                if not isinstance(mapping, dict):
+                    raise ValueError("Mapping must be a JSON object")
+            except (OSError, ValueError) as error:
+                raise RuntimeError("Local workspace mapping is unreadable; recover it before modifying bindings") from error
+        if workspace_path is not None:
+            from forgexa_cli.agent_core import acquire_workspace_write_lock
+
+            workspace_lock = acquire_workspace_write_lock(workspace_path)
+            if workspace_lock is None:
+                raise RuntimeError("A task or agent is writing this workspace; wait before changing its mapping")
         yield
     finally:
-        if lock_kind == "fcntl":
-            try:
-                import fcntl
-
-                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
-            except (ImportError, OSError):
-                pass
-        elif lock_kind == "msvcrt":
-            try:
-                import msvcrt
-
-                lock_file.seek(0)
-                msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
-            except (ImportError, OSError):
-                pass
-        lock_file.close()
+        release_file_lock(workspace_lock)
+        release_file_lock(lock_file)
 
 
 _SSH_SCHEME_RE = re.compile(r"^ssh://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/forgexa_cli/agent_core.py

@@ -1125,8 +1125,49 @@ def acquire_file_lock(
     return lock_file
 
 
+def workspace_write_lock_path(workspace_path: str | Path) -> Path:
+    """Resolve one physical worktree's shared lock without uploading its path."""
+    root = Path(workspace_path).expanduser().resolve()
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--absolute-git-dir"],
+            cwd=str(root), capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return Path(result.stdout.strip()).resolve() / "forgexa-workspace.lock"
+        if (root / ".git").exists():
+            raise RuntimeError("Could not resolve the local workspace Git metadata")
+    except (OSError, subprocess.TimeoutExpired):
+        if (root / ".git").exists():
+            raise RuntimeError("Could not resolve the local workspace Git metadata")
+    key = hashlib.sha256(str(root).encode("utf-8")).hexdigest()
+    return Path.home() / ".forgexa" / "locks" / "workspaces" / f"{key}.lock"
+
+
+def acquire_workspace_write_lock(
+    workspace_path: str | Path, *, companion_lock_path: str | Path | None = None,
+):
+    """Acquire a physical-directory lock and an optional legacy identity lock."""
+    companion = acquire_file_lock(companion_lock_path) if companion_lock_path is not None else None
+    if companion_lock_path is not None and companion is None:
+        return None
+    try:
+        physical = acquire_file_lock(workspace_write_lock_path(workspace_path))
+    except (OSError, RuntimeError):
+        release_file_lock(companion)
+        return None
+    if physical is None:
+        release_file_lock(companion)
+        return None
+    return (companion, physical) if companion is not None else physical
+
+
 def release_file_lock(lock_file) -> None:
     """Release a handle returned by :func:`acquire_file_lock` (None-safe)."""
+    if isinstance(lock_file, tuple):
+        for handle in reversed(lock_file):
+            release_file_lock(handle)
+        return
     if lock_file is None:
         return
     try:

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/forgexa_cli/daemon.py

@@ -1196,7 +1196,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.59.0"
+DAEMON_VERSION = "1.59.2"
 
 
 def _detect_client_type() -> str:
@@ -2797,7 +2797,7 @@ def _is_sensitive_local_path(path: str) -> bool:
     return any(pattern.search(normalized) for pattern in _LOCAL_BIND_SENSITIVE_PATH_PATTERNS)
 
 
-def _try_acquire_local_workspace_file_lock(binding_id: str):
+def _try_acquire_local_workspace_file_lock(binding_id: str, workspace_path: Path | None = None):
     """Non-blocking OS-level file lock keyed by binding_id.
 
     See docs/designs/forgexa-ide-design.md §6.3: the DB-side
@@ -2814,6 +2814,14 @@ def _try_acquire_local_workspace_file_lock(binding_id: str):
     agent_core.acquire_file_lock so the IDE agent_host sidecar shares them.
     """
     lock_dir = Path.home() / ".forgexa" / "locks"
+    if workspace_path is None:
+        entry = _load_local_workspaces_mapping().get(binding_id)
+        if isinstance(entry, dict) and isinstance(entry.get("local_path"), str) and entry["local_path"]:
+            workspace_path = Path(entry["local_path"]).expanduser()
+    if workspace_path is not None:
+        return agent_core.acquire_workspace_write_lock(
+            workspace_path, companion_lock_path=lock_dir / f"{binding_id}.lock",
+        )
     return agent_core.acquire_file_lock(lock_dir / f"{binding_id}.lock")
 
 
@@ -8543,6 +8551,8 @@ class ProgressReporter:
                 timeout=10,
             )
             if 200 <= response.status_code < 300:
+                if response.json().get("status") == "ignored":
+                    return False
                 self._pending_output_lines.pop(task_id, None)
                 self._last_progress_sent[task_id] = {
                     "progress_percent": progress_percent,
@@ -12120,7 +12130,17 @@ class RuntimeDaemon:
                 return
 
             # 2. Prepare workspace
-            await reporter.report_progress(task.task_id, 5, "preparing_workspace", execution_attempt_id=task.execution_attempt_id)
+            authorized = await reporter.report_progress(
+                task.task_id, 5, "preparing_workspace", execution_attempt_id=task.execution_attempt_id,
+            )
+            if is_local_bind and not authorized:
+                await report_task_complete(TaskResult(
+                    status="failed", exit_code=-1, stdout="", stderr="",
+                    error="Local execution authorization is no longer current or could not be verified",
+                    failure_code="local_binding_unavailable",
+                    execution_attempt_id=task.execution_attempt_id,
+                ))
+                return
             workspace_path = await self.workspace_manager.prepare_workspace(
                 task.project, task, runtime_id=conn.runtime_id,
             )
@@ -12782,11 +12802,18 @@ class RuntimeDaemon:
                     # directory: never `git add -A` sensitive paths, never
                     # rebase/merge/reset, fast-forward push only. See
                     # docs/designs/forgexa-ide-design.md §6.2 item 6.
-                    commit_result = await self.local_commit_and_push(
-                        workspace_path,
-                        task,
-                        before_sha=node_before_sha,
+                    authorized = await reporter.report_progress(
+                        task.task_id, 95, "verifying_local_commit_authorization",
+                        execution_attempt_id=task.execution_attempt_id,
                     )
+                    if not authorized:
+                        commit_result = {"commit_error": "Local execution authorization changed; preserving work without committing or pushing"}
+                    else:
+                        commit_result = await self.local_commit_and_push(
+                            workspace_path,
+                            task,
+                            before_sha=node_before_sha,
+                        )
                 else:
                     commit_result = await self._auto_commit(
                         workspace_path,
@@ -15811,6 +15838,17 @@ class RuntimeDaemon:
                     "then retry."
                 )}
 
+            if before_sha:
+                try:
+                    await git(
+                        "merge-base", "--is-ancestor", before_sha, "HEAD", cwd=workspace_path,
+                    )
+                except RuntimeError:
+                    return {"commit_error": (
+                        "Refusing to commit: the task baseline is no longer reachable "
+                        "from HEAD. Review the branch history yourself before retrying."
+                    )}
+
             await self._discard_transient_untracked_runtime_files(workspace_path)
             status_output = await git("status", "--porcelain", cwd=workspace_path)
             dirty_paths = [line[3:] for line in status_output.splitlines() if line.strip()]
@@ -15856,6 +15894,16 @@ class RuntimeDaemon:
                     logger.warning("Failed to build rich commit message: %s — using fallback", msg_err)
                     commit_msg = f"{task.node_type}({task.requirement_key or task.task_id}): {display_title}"
 
+                commit_branch = (
+                    await git("rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path)
+                ).strip()
+                if commit_branch != target_branch:
+                    return {"commit_error": "Refusing to commit: the task branch changed while preparing the commit"}
+                if before_sha:
+                    try:
+                        await git("merge-base", "--is-ancestor", before_sha, "HEAD", cwd=workspace_path)
+                    except RuntimeError:
+                        return {"commit_error": "Refusing to commit: the task baseline changed while preparing the commit"}
                 _git_name, _git_email = _resolve_git_author(task.project)
                 proc = await asyncio.create_subprocess_exec(
                     "git", "commit", "-m", commit_msg,
@@ -15938,9 +15986,15 @@ class RuntimeDaemon:
                     f"'{target_branch}' and retry."
                 )}
 
+            verified_head = (await git("rev-parse", "HEAD", cwd=workspace_path)).strip()
+            if before_sha:
+                try:
+                    await git("merge-base", "--is-ancestor", before_sha, verified_head, cwd=workspace_path)
+                except RuntimeError:
+                    return {"push_error": "Refusing to push: the task baseline is no longer reachable"}
             try:
                 await git(
-                    "push", "origin", current_branch,
+                    "push", "origin", f"{verified_head}:refs/heads/{target_branch}",
                     cwd=workspace_path, timeout=settings.GIT_PUSH_TIMEOUT,
                 )
             except RuntimeError as exc:

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/forgexa_cli/main.py

@@ -3297,7 +3297,7 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
     # with no tie-breaking) can resolve to the wrong, orphaned binding_id
     # instead of the one just verified. The whole read-modify-write runs
     # under the cross-process mapping lock shared with the Desktop writer.
-    with local_workspaces_mapping_lock():
+    with local_workspaces_mapping_lock(local_path):
         mapping = load_local_workspaces_mapping()
         mapping = {
             key: entry
@@ -3370,7 +3370,7 @@ def cmd_project_unbind_local(args: argparse.Namespace) -> None:
     _delete(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
     from forgexa_cli._local_bind import local_workspaces_mapping_lock
 
-    with local_workspaces_mapping_lock():  # re-read under the cross-process lock
+    with local_workspaces_mapping_lock(entry.get("local_path")):  # re-read under the cross-process lock
         mapping = load_local_workspaces_mapping()
         mapping.pop(binding_id, None)
         save_local_workspaces_mapping(mapping)

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/forgexa_cli.egg-info/PKG-INFO

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

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

{forgexa_cli-1.59.0 → forgexa_cli-1.59.2}/tests/test_local_bind_commands.py

@@ -24,6 +24,41 @@ def _init_git_repo_with_remote(path: Path, remote_url: str = "https://github.com
     subprocess.run(["git", "remote", "add", "origin", remote_url], cwd=path, check=True)
 
 
+def test_mapping_write_lock_rejects_corrupt_mapping(tmp_path, monkeypatch):
+    from forgexa_cli._local_bind import local_workspaces_mapping_lock
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    path = tmp_path / ".forgexa" / "local-workspaces.json"
+    path.parent.mkdir()
+    path.write_text("not valid json", encoding="utf-8")
+
+    with pytest.raises(RuntimeError):
+        with local_workspaces_mapping_lock():
+            pytest.fail("Corrupt mapping must not enter a write transaction")
+    assert path.read_text(encoding="utf-8") == "not valid json"
+
+
+def test_mapping_other_workspace_remains_mutable_while_one_is_busy(tmp_path, monkeypatch):
+    from forgexa_cli._local_bind import local_workspaces_mapping_lock
+    from forgexa_cli.agent_core import acquire_workspace_write_lock, release_file_lock
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    busy_repo = tmp_path / "busy"
+    free_repo = tmp_path / "free"
+    _init_git_repo_with_remote(busy_repo)
+    _init_git_repo_with_remote(free_repo)
+    path = tmp_path / ".forgexa" / "local-workspaces.json"
+    path.parent.mkdir()
+    path.write_text(json.dumps({"old": {"local_path": str(busy_repo)}}), encoding="utf-8")
+    writer = acquire_workspace_write_lock(busy_repo)
+    try:
+        assert writer is not None
+        with local_workspaces_mapping_lock(free_repo):
+            assert path.exists()
+    finally:
+        release_file_lock(writer)
+
+
 def test_bind_local_happy_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
     repo = tmp_path / "my-real-project"
@@ -55,7 +90,7 @@ def test_bind_local_happy_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch)
     args = SimpleNamespace(project="project-1", path=str(repo), runtime=None)
     main.cmd_project_bind_local(args)
 
-    assert posts[0] == ("/projects/project-1/local-workspace-bindings", {"runtime_id": "runtime-1"})
+    assert posts[0] == ("/projects/project-1/local-workspace-bindings", {"runtime_id": "runtime-1", "multi_binding_capable": True})
     assert posts[1] == ("/projects/project-1/local-workspace-bindings/binding-1/verify", {})
 
     mapping = json.loads((tmp_path / ".forgexa" / "local-workspaces.json").read_text())
@@ -66,6 +101,7 @@ def test_bind_local_happy_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch)
             "runtime_id": "runtime-1",
             "repo_identity": "github.com/acme/widgets",
             "local_path": str(repo.resolve()),
+            "share_agent_output": True,
         },
     }
 
@@ -124,6 +160,7 @@ def test_bind_local_replaces_stale_entry_for_same_local_path(tmp_path: Path, mon
             "runtime_id": "runtime-new",
             "repo_identity": "github.com/acme/widgets",
             "local_path": str(repo.resolve()),
+            "share_agent_output": True,
         },
     }
 
@@ -184,7 +221,7 @@ def test_bind_local_rejects_project_repository_mismatch_before_writing_mapping(
         main.cmd_project_bind_local(args)
 
     assert posts == [
-        ("/projects/project-1/local-workspace-bindings", {"runtime_id": "runtime-1"}),
+        ("/projects/project-1/local-workspace-bindings", {"runtime_id": "runtime-1", "multi_binding_capable": True}),
     ]
     assert deletes == ["/projects/project-1/local-workspace-bindings/binding-1"]
     assert not (tmp_path / ".forgexa" / "local-workspaces.json").exists()
@@ -228,7 +265,7 @@ def test_bind_local_uses_runtime_prefix_to_disambiguate(
 
     def fake_post(path: str, data=None):
         if path.endswith("/local-workspace-bindings"):
-            assert data == {"runtime_id": "runtime-2"}
+            assert data == {"runtime_id": "runtime-2", "multi_binding_capable": True}
             return {"id": "binding-1", "status": "pending"}
         if path.endswith("/verify"):
             return {"id": "binding-1", "status": "pending"}