forgexa-cli 1.62.2__tar.gz → 1.62.4__tar.gz

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/PKG-INFO

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

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

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/forgexa_cli/agent_core.py

@@ -3626,7 +3626,7 @@ def is_copilot_model_discovery_auth_error(*messages: str | None) -> bool:
 
 
 def is_runtime_resource_exhaustion_error(*messages: str | None) -> bool:
-    """Return whether the OS refused to create an agent process or thread."""
+    """Return whether the OS refused an agent process, thread, or file watch."""
     detail = " ".join(str(message or "").lower() for message in messages)
     return any(
         pattern in detail
@@ -3635,6 +3635,9 @@ def is_runtime_resource_exhaustion_error(*messages: str | None) -> bool:
             "failed to load ca certificates off thread",
             "resource temporarily unavailable (os error 11)",
             "pthread_create failed",
+            "os file watch limit reached",
+            "inotify watch limit reached",
+            "inotify instance limit reached",
         )
     )
 
@@ -3644,7 +3647,7 @@ def collect_runtime_resource_metrics(
     proc_root: str | Path = "/proc",
     cgroup_root: str | Path = "/sys/fs/cgroup",
 ) -> dict[str, Any]:
-    """Collect Linux process/thread headroom without optional dependencies."""
+    """Collect Linux process/thread, memory, and file-watch capacity."""
     metrics: dict[str, Any] = {}
     if not sys.platform.startswith("linux"):
         return metrics
@@ -3714,11 +3717,36 @@ def collect_runtime_resource_metrics(
                 break
     except (OSError, ValueError, IndexError):
         pass
+
+    probe_fd: int | None = None
+    try:
+        for name in ("max_user_watches", "max_user_instances"):
+            metrics[f"inotify_{name}"] = int(
+                (proc_path / "sys" / "fs" / "inotify" / name).read_text().strip()
+            )
+        import ctypes
+
+        library = ctypes.CDLL(None, use_errno=True)
+        library.inotify_init1.argtypes = [ctypes.c_int]
+        library.inotify_init1.restype = ctypes.c_int
+        library.inotify_add_watch.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_uint32]
+        library.inotify_add_watch.restype = ctypes.c_int
+        probe_fd = library.inotify_init1(os.O_CLOEXEC | os.O_NONBLOCK)
+        if probe_fd < 0:
+            metrics["inotify_probe_errno"] = ctypes.get_errno()
+        else:
+            watch = library.inotify_add_watch(probe_fd, os.fsencode(proc_path), 0x00000004)
+            metrics["inotify_probe_errno"] = ctypes.get_errno() if watch < 0 else 0
+    except (AttributeError, OSError, ValueError):
+        pass
+    finally:
+        if probe_fd is not None and probe_fd >= 0:
+            os.close(probe_fd)
     return metrics
 
 
 def runtime_resource_exhaustion_reason(metrics: dict[str, Any]) -> str | None:
-    """Return a blocking reason when an agent lacks safe process headroom."""
+    """Return a blocking reason when the OS cannot safely start an agent."""
     process_remaining = metrics.get("process_remaining")
     if isinstance(process_remaining, int) and process_remaining < 32:
         return (
@@ -3729,9 +3757,41 @@ def runtime_resource_exhaustion_reason(metrics: dict[str, Any]) -> str | None:
     memory_available_mb = metrics.get("memory_available_mb")
     if isinstance(memory_available_mb, int) and memory_available_mb < 256:
         return f"Only {memory_available_mb} MiB memory is available"
+    import errno
+
+    probe_errno = metrics.get("inotify_probe_errno")
+    if probe_errno == errno.ENOSPC:
+        return (
+            "OS file watch limit reached (inotify ENOSPC; "
+            f"fs.inotify.max_user_watches={metrics.get('inotify_max_user_watches')})"
+        )
+    if probe_errno in {errno.EMFILE, errno.ENFILE}:
+        return (
+            "Inotify instance or file descriptor limit reached "
+            f"({errno.errorcode[probe_errno]}; "
+            f"fs.inotify.max_user_instances={metrics.get('inotify_max_user_instances')})"
+        )
     return None
 
 
+def runtime_resource_exhaustion_remediation(metrics: dict[str, Any]) -> str:
+    """Suggest recovery for the specific resource rejected by the kernel."""
+    import errno
+
+    probe_errno = metrics.get("inotify_probe_errno")
+    if probe_errno == errno.ENOSPC:
+        return (
+            "Inspect and stop unneeded file watchers owned by the daemon user, "
+            "or raise fs.inotify.max_user_watches, then retry"
+        )
+    if probe_errno in {errno.EMFILE, errno.ENFILE}:
+        return (
+            "Close unused watcher processes or file descriptors; check "
+            "fs.inotify.max_user_instances and the file descriptor limits, then retry"
+        )
+    return "Stop orphaned agent processes or raise the user/cgroup PID limit, then retry"
+
+
 def copilot_auth_state_signature(copilot_home: str | Path) -> str | None:
     """Return a content signature for Copilot's persisted authentication state."""
     config_file = Path(copilot_home) / "config.json"

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/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.62.2"
+DAEMON_VERSION = "1.62.4"
 
 
 def _detect_client_type() -> str:
@@ -5919,6 +5919,8 @@ class ProcessManager:
         lower = (text or "").lower()
         if any(p in lower for p in ProcessManager.RATE_LIMIT_PATTERNS):
             return "Agent hit rate/usage limit or quota exhaustion"
+        if agent_core.is_runtime_resource_exhaustion_error(lower):
+            return "Agent host OS resources exhausted"
         if any(p in lower for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS):
             return "Agent backend unavailable or unreachable"
         return None
@@ -6015,11 +6017,13 @@ class ProcessManager:
             "all_agents_rate_limited", "all_agents_unavailable", "acceptance_criteria_uncovered",
         }:
             return None
-        if result.failure_code == "agent_platform_unsupported":
+        if result.failure_code in {"agent_platform_unsupported", "runtime_resource_exhausted"}:
             return "agent_unavailable"
         error_text = ProcessManager._failure_pattern_channels(result).lower()
         if any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS):
             return "rate_limit"
+        if agent_core.is_runtime_resource_exhaustion_error(error_text):
+            return "agent_unavailable"
         if any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS):
             return "agent_unavailable"
         return None
@@ -6192,9 +6196,8 @@ class ProcessManager:
                 "blocking": True,
                 "failure_class": "resource_exhausted",
                 "detail": resource_reason,
-                "remediation": (
-                    "Stop orphaned agent processes or raise the user/cgroup PID limit, "
-                    "then retry"
+                "remediation": agent_core.runtime_resource_exhaustion_remediation(
+                    resource_metrics,
                 ),
             }
             logger.error(
@@ -8741,9 +8744,8 @@ class RuntimePreflightMonitor:
                 "blocking": True,
                 "failure_class": "resource_exhausted",
                 "detail": reason,
-                "remediation": (
-                    "Stop orphaned agent processes or raise the user/cgroup PID limit, "
-                    "then restart the daemon"
+                "remediation": agent_core.runtime_resource_exhaustion_remediation(
+                    metrics,
                 ),
             }
         if metrics:

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/forgexa_cli/main.py

@@ -3266,7 +3266,8 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
             )
             break
 
-    if binding is None:
+    created_binding = binding is None
+    if created_binding:
         binding = _post(
             f"/projects/{args.project}/local-workspace-bindings",
             {"runtime_id": runtime["id"], "multi_binding_capable": True},
@@ -3275,69 +3276,85 @@ def cmd_project_bind_local(args: argparse.Namespace) -> None:
     if not binding_id:
         print("Error: failed to create local workspace binding", file=sys.stderr)
         sys.exit(1)
-    expected_identity = binding.get("repo_identity")
-    if isinstance(expected_identity, str) and expected_identity != identity:
-        try:
-            _delete(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
-        except Exception:
-            pass
-        print(
-            "Error: this folder's Git remote does not match the selected Forgexa project's repository "
-            f"(project: {expected_identity}, this folder: {identity}). "
-            "Open the matching folder or update the project's repository URL.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    # 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
-    # attempt (e.g. a re-registered runtime after a reinstall, or a
-    # 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. The whole read-modify-write runs
-    # under the cross-process mapping lock shared with the Desktop writer.
-    with local_workspaces_mapping_lock(local_path):
-        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
-    while True:
-        verified = _get(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
-        status = verified.get("status", "unknown") if isinstance(verified, dict) else "unknown"
-        if status == "active":
-            print(f"Bound {local_path} to project {args.project} (binding {binding_id[:8]}, status: active)")
-            break
-        if status == "stale":
-            print(
-                f"Local daemon could not verify binding {binding_id[:8]}: "
-                f"{verified.get('validation_error') or 'unknown validation failure'}",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        if time.monotonic() >= deadline:
+    try:
+        expected_identity = binding.get("repo_identity")
+        if isinstance(expected_identity, str) and expected_identity != identity:
             print(
-                f"Timed out waiting for the daemon to verify binding {binding_id[:8]}. "
-                "Restart or update the daemon and try again.",
+                "Error: this folder's Git remote does not match the selected Forgexa project's repository "
+                f"(project: {expected_identity}, this folder: {identity}). "
+                "Open the matching folder or update the project's repository URL.",
                 file=sys.stderr,
             )
             sys.exit(1)
-        time.sleep(1)
+        if not created_binding and binding.get("status") == "active":
+            print(f"Bound {local_path} to project {args.project} (binding {binding_id[:8]}, status: active)")
+            return
+
+        # 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
+        # attempt (e.g. a re-registered runtime after a reinstall, or a
+        # 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. The whole read-modify-write runs
+        # under the cross-process mapping lock shared with the Desktop writer.
+        with local_workspaces_mapping_lock(local_path):
+            mapping = load_local_workspaces_mapping()
+            share_agent_output = mapping.get(binding_id, {}).get("share_agent_output") is not False
+            mapping = {
+                key: entry
+                for key, entry in mapping.items()
+                if key == binding_id
+                or Path(str(entry.get("local_path") or "")).expanduser().resolve() != local_path
+            }
+            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": share_agent_output,
+            }
+            save_local_workspaces_mapping(mapping)
+
+        _post(f"/projects/{args.project}/local-workspace-bindings/{binding_id}/verify")
+        deadline = time.monotonic() + 35
+        while True:
+            verified = _get(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
+            status = verified.get("status", "unknown") if isinstance(verified, dict) else "unknown"
+            if status == "active":
+                print(f"Bound {local_path} to project {args.project} (binding {binding_id[:8]}, status: active)")
+                break
+            if status == "revoked":
+                print(f"Local workspace binding {binding_id[:8]} was revoked; bind this folder again.", file=sys.stderr)
+                sys.exit(1)
+            if status == "stale":
+                print(
+                    f"Local daemon could not verify binding {binding_id[:8]}: "
+                    f"{verified.get('validation_error') or 'unknown validation failure'}",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            if time.monotonic() >= deadline:
+                print(
+                    f"Timed out waiting for the daemon to verify binding {binding_id[:8]}. "
+                    "Restart or update the daemon and try again.",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+            time.sleep(1)
+    except (Exception, SystemExit, KeyboardInterrupt):
+        if created_binding:
+            try:
+                _delete(f"/projects/{args.project}/local-workspace-bindings/{binding_id}")
+                with local_workspaces_mapping_lock(local_path):
+                    mapping = load_local_workspaces_mapping()
+                    if mapping.pop(binding_id, None) is not None:
+                        save_local_workspaces_mapping(mapping)
+            except (Exception, SystemExit):
+                pass
+        raise
 
 
 def cmd_project_unbind_local(args: argparse.Namespace) -> None:

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/forgexa_cli.egg-info/PKG-INFO

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

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

{forgexa_cli-1.62.2 → forgexa_cli-1.62.4}/tests/test_local_bind_commands.py

@@ -106,7 +106,10 @@ def test_bind_local_happy_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch)
     }
 
 
-def test_bind_local_replaces_stale_entry_for_same_local_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+@pytest.mark.parametrize("path_alias", [False, True])
+def test_bind_local_replaces_stale_entry_for_same_local_path(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, path_alias: bool,
+) -> None:
     """A stale entry from an earlier attempt (e.g. before a daemon/runtime
     reinstall) must not linger alongside a freshly-verified one for the same
     folder - agent_host.py's _match_local_binding_id does a plain path scan
@@ -125,7 +128,7 @@ def test_bind_local_replaces_stale_entry_for_same_local_path(tmp_path: Path, mon
             "user_id": "user-1",
             "runtime_id": "runtime-old",
             "repo_identity": "github.com/acme/widgets",
-            "local_path": str(repo.resolve()),
+            "local_path": str(repo.resolve()) + ("/." if path_alias else ""),
         },
     }))
 
@@ -165,6 +168,112 @@ def test_bind_local_replaces_stale_entry_for_same_local_path(tmp_path: Path, mon
     }
 
 
+@pytest.mark.parametrize("stage", ["mapping", "verification", "stale", "revoked", "timeout", "rollback"])
+def test_bind_local_rolls_back_only_new_binding_on_failure(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, stage: str,
+) -> None:
+    from forgexa_cli import _local_bind
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    repo = tmp_path / "widgets"
+    _init_git_repo_with_remote(repo)
+    mapping_path = tmp_path / ".forgexa" / "local-workspaces.json"
+    mapping_path.parent.mkdir()
+    original = {"binding-other": {"project_id": "project-1", "local_path": str(tmp_path / "other")}}
+    mapping_path.write_text(json.dumps(original))
+    monkeypatch.setattr(main, "_get_runtimes", lambda: [{"id": "runtime-1", "pool_type": "personal"}])
+    deletes = []
+
+    def fake_get(path: str):
+        if path == "/auth/me":
+            return {"id": "user-1"}
+        return {"id": "binding-new", "status": stage if stage in ("stale", "revoked") else "pending"}
+
+    def fake_post(path: str, data=None):
+        if path.endswith("/local-workspace-bindings"):
+            return {"id": "binding-new", "status": "pending", "repo_identity": "github.com/acme/widgets"}
+        if stage in ("verification", "rollback"):
+            raise RuntimeError("Verification unavailable")
+        return {"status": "pending"}
+
+    def fake_delete(path: str):
+        deletes.append(path)
+        if stage == "rollback":
+            raise SystemExit(1)
+
+    monkeypatch.setattr(main, "_get", fake_get)
+    monkeypatch.setattr(main, "_post", fake_post)
+    monkeypatch.setattr(main, "_delete", fake_delete)
+    clock = iter([0, 36])
+    monkeypatch.setattr(main, "time", SimpleNamespace(
+        monotonic=lambda: next(clock, 36),
+        sleep=lambda duration: pytest.fail("A terminal failure must not keep polling"),
+    ))
+    if stage == "mapping":
+        def fail_save(mapping):
+            raise RuntimeError("Mapping unavailable")
+        monkeypatch.setattr(_local_bind, "save_local_workspaces_mapping", fail_save)
+
+    args = SimpleNamespace(project="project-1", path=str(repo), runtime=None)
+    with pytest.raises((SystemExit, RuntimeError)):
+        main.cmd_project_bind_local(args)
+
+    assert deletes == ["/projects/project-1/local-workspace-bindings/binding-new"]
+    mapping = json.loads(mapping_path.read_text())
+    assert mapping["binding-other"] == original["binding-other"]
+    assert ("binding-new" in mapping) == (stage == "rollback")
+
+
+@pytest.mark.parametrize("status", ["active", "stale", "repository_mismatch"])
+def test_bind_local_preserves_existing_binding_and_output_sharing(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, status: str,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    repo = tmp_path / "widgets"
+    _init_git_repo_with_remote(repo)
+    mapping_path = tmp_path / ".forgexa" / "local-workspaces.json"
+    mapping_path.parent.mkdir()
+    entry = {
+        "project_id": "project-1", "user_id": "user-1", "runtime_id": "runtime-1",
+        "repo_identity": "github.com/acme/widgets", "local_path": str(repo),
+        "share_agent_output": False,
+    }
+    mapping_path.write_text(json.dumps({"binding-existing": entry}))
+    monkeypatch.setattr(main, "_get_runtimes", lambda: [{"id": "runtime-1", "pool_type": "personal"}])
+    posts = []
+    deletes = []
+
+    def fake_get(path: str):
+        if path == "/auth/me":
+            return {"id": "user-1"}
+        if path.endswith("/local-workspace-bindings"):
+            return [{
+                "id": "binding-existing", "status": "active" if status == "repository_mismatch" else status,
+                "repo_identity": "github.com/acme/other" if status == "repository_mismatch" else "github.com/acme/widgets",
+                "lease_held": status == "active",
+            }]
+        return {"id": "binding-existing", "status": "active"}
+
+    def fake_post(path: str, data=None):
+        posts.append(path)
+        assert path.endswith("/verify")
+        return {"status": "pending"}
+
+    monkeypatch.setattr(main, "_get", fake_get)
+    monkeypatch.setattr(main, "_post", fake_post)
+    monkeypatch.setattr(main, "_delete", lambda path: deletes.append(path))
+    args = SimpleNamespace(project="project-1", path=str(repo), runtime=None)
+    if status == "repository_mismatch":
+        with pytest.raises(SystemExit):
+            main.cmd_project_bind_local(args)
+    else:
+        main.cmd_project_bind_local(args)
+
+    assert posts == (["/projects/project-1/local-workspace-bindings/binding-existing/verify"] if status == "stale" else [])
+    assert deletes == []
+    assert json.loads(mapping_path.read_text()) == {"binding-existing": entry}
+
+
 def test_bind_local_rejects_non_git_directory(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
     plain_dir = tmp_path / "not-a-repo"