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

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

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

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

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

@@ -11,11 +11,13 @@ changes. See docs/designs/forgexa-ide-design.md §6.1/§6.2/§6.4.
 """
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import re
 import subprocess
 from pathlib import Path
+from typing import Iterator
 
 
 def local_workspaces_mapping_path() -> Path:
@@ -44,6 +46,61 @@ def save_local_workspaces_mapping(mapping: dict) -> None:
     tmp_path.replace(path)
 
 
+@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).
+    """
+    path = local_workspaces_mapping_path()
+    lock_path = path.with_name(path.name + ".lock")
+    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:
+            try:
+                import msvcrt
+
+                lock_file.seek(0)
+                msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
+                lock_kind = "msvcrt"
+            except (ImportError, OSError):
+                pass
+        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()
+
+
 _SSH_SCHEME_RE = re.compile(r"^ssh://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _HTTP_SCHEME_RE = re.compile(r"^https?://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$")
 _SCP_LIKE_RE = re.compile(r"^[^@/]+@([^:/]+):(.+?)(?:\.git)?/?$")

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

@@ -1058,6 +1058,32 @@ except (ImportError, ModuleNotFoundError):
         def GIT_CLONE_TIMEOUT(self) -> int:
             return int(os.environ.get("GIT_CLONE_TIMEOUT", "1800"))
 
+        @property
+        def GIT_WORKTREE_TIMEOUT(self) -> int:
+            """Timeout (seconds) for `git worktree add` operations.
+
+            `worktree add` materialises a full checkout of the target branch
+            into the new worktree.  On large repos (e.g. HP SI) or busy disks
+            this easily exceeds the 120 s default for ordinary git commands
+            (SI-1181: a fresh-start worktree add timed out after 120 s and
+            failed the node even though the checkout was still progressing).
+
+            Precedence:
+              1. GIT_WORKTREE_TIMEOUT env var (explicit override)
+              2. GIT_CLONE_TIMEOUT env var (backwards compat — an operator
+                 who raised the clone timeout for a huge repo wants local
+                 checkouts to get comparable headroom)
+              3. 600 s default (10 min — local disk I/O only, no network,
+                 so shorter than the clone/fetch/push ceiling)
+            """
+            env_worktree = os.environ.get("GIT_WORKTREE_TIMEOUT")
+            if env_worktree:
+                return int(env_worktree)
+            env_clone = os.environ.get("GIT_CLONE_TIMEOUT")
+            if env_clone:
+                return int(env_clone)
+            return 600
+
         @property
         def GIT_FETCH_TIMEOUT(self) -> int:
             """Timeout (seconds) for incremental git fetch operations.
@@ -1170,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.58.2"
+DAEMON_VERSION = "1.59.0"
 
 
 def _detect_client_type() -> str:
@@ -5436,7 +5462,8 @@ class WorkspaceManager:
                         ) from recovery_exc
                 self._safe_rmtree(ws_path)
                 raise RuntimeError(
-                    f"Failed to create clean fresh worktree for branch '{branch_name}'. "
+                    f"Failed to create clean fresh worktree for branch '{branch_name}': "
+                    f"{self._summarize_git_error(exc)}. "
                     "Refusing to reuse a stale local branch."
                 ) from exc
         else:
@@ -5472,13 +5499,18 @@ class WorkspaceManager:
         """Optional cleanup after task. For now, keep workspaces for debugging."""
         pass
 
-    async def _git(self, *args: str, cwd: Path | str | None = None, timeout: int = 120,
+    async def _git(self, *args: str, cwd: Path | str | None = None, timeout: int | None = None,
                    project_key: str | None = None) -> str:
         """Run a git command safely using exec (no shell injection).
 
         If a project SSH key is registered, remote-touching commands
         (clone, fetch, pull, push) will use GIT_SSH_COMMAND.
 
+        Timeout resolution (SI-1181): when ``timeout`` is None the default
+        is 120 s for ordinary git commands, but `worktree add` — which
+        materialises a full checkout of the branch — gets the dedicated
+        GIT_WORKTREE_TIMEOUT (default 600 s) instead.
+
         Process-group isolation: git is started in its own session so that
         SIGKILL on timeout propagates to all of git's children (especially
         the ssh subprocess that git forks for remote operations).  Without
@@ -5491,6 +5523,15 @@ class WorkspaceManager:
         accepts but never sends the git protocol banner) is detected within
         ~90 s rather than waiting forever.
         """
+        if timeout is None:
+            # `git worktree add` is a full checkout of the target branch;
+            # on large repos (e.g. HP SI) or busy disks it legitimately
+            # exceeds the 120 s default for ordinary git commands.
+            timeout = (
+                settings.GIT_WORKTREE_TIMEOUT
+                if args[:2] == ("worktree", "add")
+                else 120
+            )
         env = None
         git_prefix_args: list[str] = []
         # Inject SSH key for commands that touch the remote
@@ -8466,6 +8507,7 @@ class ProgressReporter:
         files_changed: list[str] | None = None,
         lines_added: int = 0,
         lines_removed: int = 0,
+        execution_attempt_id: str | None = None,
     ) -> bool:
         output_lines = [
             *self._pending_output_lines.get(task_id, []),
@@ -8496,6 +8538,7 @@ class ProgressReporter:
                     "files_changed": files_changed,
                     "lines_added": lines_added,
                     "lines_removed": lines_removed,
+                    "execution_attempt_id": execution_attempt_id,
                 },
                 timeout=10,
             )
@@ -8976,7 +9019,7 @@ class HeartbeatService:
                         "active_tasks": self._active_tasks,
                         "available_agents": self._agents,
                         "capabilities": {
-                            "local_workspace_bindings": {"protocol_version": 3},
+                            "local_workspace_bindings": {"protocol_version": 4},
                             "local_commit_and_push": {"protocol_version": 1},
                             "local_fresh_branch_reset": {
                                 "protocol_version": _LOCAL_FRESH_BRANCH_RESET_PROTOCOL_VERSION,
@@ -9346,7 +9389,7 @@ class ServerConnection:
             "capabilities": {
                 "platform": platform.platform(),
                 "python_version": platform.python_version(),
-                "local_workspace_bindings": {"protocol_version": 3},
+                "local_workspace_bindings": {"protocol_version": 4},
                 "local_commit_and_push": {"protocol_version": 1},
                 "local_fresh_branch_reset": {
                     "protocol_version": _LOCAL_FRESH_BRANCH_RESET_PROTOCOL_VERSION,
@@ -9766,7 +9809,7 @@ class ServerConnection:
                 "capabilities": {
                     "platform": platform.platform(),
                     "python_version": platform.python_version(),
-                    "local_workspace_bindings": {"protocol_version": 3},
+                    "local_workspace_bindings": {"protocol_version": 4},
                     "local_commit_and_push": {"protocol_version": 1},
                     "local_fresh_branch_reset": {
                         "protocol_version": _LOCAL_FRESH_BRANCH_RESET_PROTOCOL_VERSION,
@@ -11982,7 +12025,7 @@ class RuntimeDaemon:
                 task.task_id,
                 project_lock_key,
             )
-            await reporter.report_progress(task.task_id, 1, "waiting_for_execution_lock")
+            await reporter.report_progress(task.task_id, 1, "waiting_for_execution_lock", execution_attempt_id=task.execution_attempt_id)
         await project_lock.acquire()
         workspace_execution_lock: _WorkspaceFileLock | None = None
         local_bind_file_lock = None
@@ -12042,7 +12085,7 @@ class RuntimeDaemon:
                 ))
                 return
 
-            await reporter.report_progress(task.task_id, 3, "waiting_for_workspace_lock")
+            await reporter.report_progress(task.task_id, 3, "waiting_for_workspace_lock", execution_attempt_id=task.execution_attempt_id)
             workspace_execution_lock = await self.workspace_manager.acquire_workspace_execution_lock(
                 task.project,
                 task,
@@ -12077,7 +12120,7 @@ class RuntimeDaemon:
                 return
 
             # 2. Prepare workspace
-            await reporter.report_progress(task.task_id, 5, "preparing_workspace")
+            await reporter.report_progress(task.task_id, 5, "preparing_workspace", execution_attempt_id=task.execution_attempt_id)
             workspace_path = await self.workspace_manager.prepare_workspace(
                 task.project, task, runtime_id=conn.runtime_id,
             )
@@ -12096,6 +12139,7 @@ class RuntimeDaemon:
                         8,
                         "preparing_attachments",
                         output_lines=["[daemon] Preparing task attachments"],
+                        execution_attempt_id=task.execution_attempt_id,
                     )
                 attachment_staging_dir = await self._stage_task_attachments(task, conn)
             except _TaskAttachmentDownloadError as exc:
@@ -12105,6 +12149,7 @@ class RuntimeDaemon:
                     8,
                     "attachment_download_failed",
                     output_lines=["[daemon] Required task attachment could not be downloaded"],
+                    execution_attempt_id=task.execution_attempt_id,
                 )
                 await report_task_complete(TaskResult(
                     status="failed",
@@ -12145,7 +12190,7 @@ class RuntimeDaemon:
                 )
 
             # 3. Run agent with real-time output streaming + periodic progress heartbeat
-            await reporter.report_progress(task.task_id, 10, "running_agent")
+            await reporter.report_progress(task.task_id, 10, "running_agent", execution_attempt_id=task.execution_attempt_id)
 
             # Buffer cloud output or local-bind activity summaries between
             # ticks so the server accumulates a real-time, safe display log.
@@ -12184,6 +12229,7 @@ class RuntimeDaemon:
                         progress_percent,
                         current_step,
                         activity_lines=output_lines,
+                        execution_attempt_id=task.execution_attempt_id,
                     )
                 else:
                     await reporter.report_progress(
@@ -12191,6 +12237,7 @@ class RuntimeDaemon:
                         progress_percent,
                         current_step,
                         output_lines=output_lines,
+                        execution_attempt_id=task.execution_attempt_id,
                     )
 
             async def _progress_ticker():
@@ -12311,6 +12358,7 @@ class RuntimeDaemon:
                         task.task_id, 10,
                         f"agent_fallback: retrying with {agent.agent_id}",
                         output_lines=[f"[daemon] Agent {fallback_label}, switching to {agent.agent_id}"],
+                        execution_attempt_id=task.execution_attempt_id,
                     )
 
                     # Re-run with fallback agent
@@ -12560,6 +12608,7 @@ class RuntimeDaemon:
                             f"[daemon] Agent {post_validation_failure_label} during validation, "
                             f"switching to {agent.agent_id}",
                         ],
+                        execution_attempt_id=task.execution_attempt_id,
                     )
                     result = await self.process_manager.run_agent(
                         agent, task, workspace_path, on_chunk=on_output_chunk,
@@ -12833,7 +12882,7 @@ class RuntimeDaemon:
                     )
 
             if result.status == "success" and task.critic_review_required:
-                await reporter.report_progress(task.task_id, 95, "running_critic_review")
+                await reporter.report_progress(task.task_id, 95, "running_critic_review", execution_attempt_id=task.execution_attempt_id)
                 result.critic_review = await self._run_runtime_critic_review(
                     task,
                     agent,
@@ -12852,7 +12901,7 @@ class RuntimeDaemon:
                     or "validation_retry_exhausted"
                 )
             result.execution_attempt_id = task.execution_attempt_id
-            await reporter.report_progress(task.task_id, 100, "completed" if result.status == "success" else "failed")
+            await reporter.report_progress(task.task_id, 100, "completed" if result.status == "success" else "failed", execution_attempt_id=task.execution_attempt_id)
             await report_task_complete(result)
 
             logger.info("Task %s completed: %s (agent=%s)", task.task_id, result.status, agent.agent_id)
@@ -15722,6 +15771,10 @@ class RuntimeDaemon:
         broadly `git add -A`s and may rebase/force-push onto the latest
         default branch), this adapter never touches the user's real
         directory beyond a plain stage+commit+fast-forward-push:
+        - re-verifies the directory is still on the task's workspace_branch
+          before staging and again before pushing: if the user switched
+          branches while the agent ran, the task fails closed instead of
+          committing/pushing the changes onto the wrong branch
         - refuses to commit if any changed path (staged, or already
           committed by the agent itself since before_sha) looks like a
           secret (.env, private keys, etc.) — fails the task closed rather
@@ -15738,6 +15791,26 @@ class RuntimeDaemon:
         """
         git = self.workspace_manager._git
         try:
+            target_branch = task.workspace_branch
+            if not target_branch:
+                return {"commit_error": (
+                    "Refusing to commit: no workspace_branch recorded for this "
+                    "local_bind task — cannot verify the directory is still on "
+                    "the task's branch."
+                )}
+            current_branch = (
+                await git("rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path)
+            ).strip()
+            if current_branch != target_branch:
+                return {"commit_error": (
+                    f"Refusing to commit: local directory is on branch "
+                    f"'{current_branch}', but this task started on "
+                    f"'{target_branch}'. The branch was switched while the "
+                    "task was running (outside Forgexa). Switch back to "
+                    f"'{target_branch}' and review the working tree yourself, "
+                    "then retry."
+                )}
+
             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()]
@@ -15857,6 +15930,13 @@ class RuntimeDaemon:
                 return {"push_error": f"failed to read current branch: {exc}"}
             if not current_branch or current_branch == "HEAD":
                 return {"push_error": "not on a branch (detached HEAD) — refusing to push"}
+            if current_branch != target_branch:
+                return {"push_error": (
+                    f"Refusing to push: local directory moved to branch "
+                    f"'{current_branch}' after commit; this task ran on "
+                    f"'{target_branch}'. Nothing was pushed — switch back to "
+                    f"'{target_branch}' and retry."
+                )}
 
             try:
                 await git(

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

@@ -3152,6 +3152,7 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
     from forgexa_cli._local_bind import (
         load_local_workspaces_mapping,
         local_git_remote_identity,
+        local_workspaces_mapping_lock,
         save_local_workspaces_mapping,
     )
 
@@ -3201,10 +3202,74 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
         print("Error: could not resolve current user (are you logged in?)", file=sys.stderr)
         sys.exit(1)
 
-    binding = _post(
-        f"/projects/{args.project}/local-workspace-bindings",
-        {"runtime_id": runtime["id"]},
-    )
+    # Reuse the binding this directory is already mapped to when there is
+    # one — the server never sees paths, so directory identity is a local
+    # question (multi-workspace parallel design §6.1). Only create when the
+    # mapping has no candidate or the server-side binding is gone/revoked;
+    # this keeps a re-link from piling up duplicate bindings for the same
+    # directory on projects that allow several bindings per runtime.
+    mapping = load_local_workspaces_mapping()
+    local_path_str = str(local_path)
+    binding = None
+    server_bindings = None
+    for mapping_id, entry in mapping.items():
+        entry_path = str(entry.get("local_path") or "")
+        try:
+            entry_path = str(Path(entry_path).expanduser().resolve())
+        except OSError:
+            pass
+        if (
+            entry_path == local_path_str
+            and entry.get("project_id") == args.project
+            and entry.get("runtime_id") == runtime["id"]
+            and entry.get("user_id") == user_id
+        ):
+            if server_bindings is None:
+                server_bindings = _get(f"/projects/{args.project}/local-workspace-bindings")
+            existing = next(
+                (
+                    b
+                    for b in server_bindings
+                    if isinstance(b, dict) and b.get("id") == mapping_id
+                ),
+                None,
+            )
+            if isinstance(existing, dict) and existing.get("status") in ("pending", "active", "stale"):
+                binding = existing
+            break
+
+    # Directory↔project bijection (multi-workspace design §7.1): one physical
+    # directory belongs to exactly one project at a time. Re-binding it to a
+    # different project swaps ownership (the old binding goes stale) — refuse
+    # without an explicit --force so picking the wrong project can never
+    # masquerade as "adding another workspace".
+    for entry in mapping.values():
+        entry_path = str(entry.get("local_path") or "")
+        try:
+            entry_path = str(Path(entry_path).expanduser().resolve())
+        except OSError:
+            pass
+        if entry_path == local_path_str and entry.get("project_id") != args.project:
+            if not getattr(args, "force", False):
+                print(
+                    f"Error: {local_path} is currently bound to project {entry.get('project_id')}. "
+                    "One directory belongs to exactly one project at a time; re-binding releases the old "
+                    "binding (it turns stale). If this folder really should change projects, re-run with "
+                    "--force. To add another workspace of the SAME project, bind the other folder instead.",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            print(
+                f"Warning: re-binding {local_path} from project {entry.get('project_id')} to {args.project}",
+                file=sys.stderr,
+            )
+            break
+
+    if binding is None:
+        binding = _post(
+            f"/projects/{args.project}/local-workspace-bindings",
+            {"runtime_id": runtime["id"], "multi_binding_capable": True},
+        )
     binding_id = binding.get("id")
     if not binding_id:
         print("Error: failed to create local workspace binding", file=sys.stderr)
@@ -3223,8 +3288,6 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
         )
         sys.exit(1)
 
-    mapping = load_local_workspaces_mapping()
-    local_path_str = str(local_path)
     # A folder can only ever be validly bound to one binding_id at a time -
     # drop any other (necessarily stale) entry already pointing at this same
     # path first. Without this, a stale entry left behind by an earlier
@@ -3232,21 +3295,24 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
     # verification that timed out client-side) can linger alongside the new
     # one, and agent_host.py's `_match_local_binding_id` (a plain path scan
     # with no tie-breaking) can resolve to the wrong, orphaned binding_id
-    # instead of the one just verified.
-    mapping = {
-        key: entry
-        for key, entry in mapping.items()
-        if key == binding_id or entry.get("local_path") != local_path_str
-    }
-    mapping[binding_id] = {
-        "project_id": args.project,
-        "user_id": user_id,
-        "runtime_id": runtime["id"],
-        "repo_identity": identity,
-        "local_path": str(local_path),
-        "share_agent_output": True,
-    }
-    save_local_workspaces_mapping(mapping)
+    # 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():
+        mapping = load_local_workspaces_mapping()
+        mapping = {
+            key: entry
+            for key, entry in mapping.items()
+            if key == binding_id or entry.get("local_path") != local_path_str
+        }
+        mapping[binding_id] = {
+            "project_id": args.project,
+            "user_id": user_id,
+            "runtime_id": runtime["id"],
+            "repo_identity": identity,
+            "local_path": str(local_path),
+            "share_agent_output": True,
+        }
+        save_local_workspaces_mapping(mapping)
 
     _post(f"/projects/{args.project}/local-workspace-bindings/{binding_id}/verify")
     deadline = time.monotonic() + 35
@@ -3302,9 +3368,12 @@ def cmd_project_unbind_local(args: argparse.Namespace) -> None:
 
     binding_id, entry = matches[0]
     _delete(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
-    mapping = load_local_workspaces_mapping()  # re-read in case of concurrent writes
-    mapping.pop(binding_id, None)
-    save_local_workspaces_mapping(mapping)
+    from forgexa_cli._local_bind import local_workspaces_mapping_lock
+
+    with local_workspaces_mapping_lock():  # re-read under the cross-process lock
+        mapping = load_local_workspaces_mapping()
+        mapping.pop(binding_id, None)
+        save_local_workspaces_mapping(mapping)
     print(f"Unbound {entry.get('local_path', '')} from project {args.project} (binding {binding_id[:8]})")
 
 
@@ -3924,6 +3993,12 @@ def main() -> None:
     bl.add_argument("path", help="Absolute path to your local working directory")
     bl.add_argument("--project", required=True, help="Project ID")
     bl.add_argument("--runtime", default=None, help="Personal runtime ID prefix (if you have more than one)")
+    bl.add_argument(
+        "--force",
+        action="store_true",
+        help="Allow re-binding a directory that currently belongs to a DIFFERENT project "
+        "(the old binding turns stale on the daemon's next validation cycle)",
+    )
     ul = proj_sub.add_parser("unbind-local", help="Revoke a local directory binding")
     ul.add_argument("--project", required=True, help="Project ID")
     ul.add_argument("--binding", default=None, help="Binding ID prefix (if you have more than one for this project)")

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

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

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