forgexa-cli 1.62.3__tar.gz → 1.62.5__tar.gz

{forgexa_cli-1.62.3 → forgexa_cli-1.62.5}/PKG-INFO

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

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

{forgexa_cli-1.62.3 → forgexa_cli-1.62.5}/forgexa_cli/agent_core.py

@@ -48,6 +48,7 @@ import logging
 import os
 import platform
 import re
+import shlex
 import shutil
 import subprocess
 import tempfile
@@ -862,8 +863,11 @@ class AgentDiscovery:
         """Reject a Windows-side agent before its version probe can run via WSL interop."""
         if sys.platform != "linux" or not os.environ.get("WSL_DISTRO_NAME"):
             return False
-        resolved = Path(path).resolve()
-        if resolved.suffix.lower() in {".exe", ".cmd", ".bat"}:
+        try:
+            resolved = Path(path).resolve()
+        except (OSError, RuntimeError):
+            return True
+        if resolved.suffix.lower() in {".exe", ".cmd", ".bat", ".ps1", ".com"}:
             return True
         parts = resolved.parts
         if len(parts) >= 3 and parts[1] == "mnt" and len(parts[2]) == 1 and parts[2].isalpha():
@@ -872,15 +876,80 @@ class AgentDiscovery:
         try:
             mounts = Path("/proc/mounts").read_text(encoding="utf-8")
         except OSError:
-            return False
+            return True
         for line in mounts.splitlines():
             fields = line.split()
             if len(fields) >= 3 and fields[2] in {"9p", "drvfs"}:
-                mount = Path(fields[1].replace("\\040", " "))
+                mount = Path(re.sub(r"\\([0-7]{3})", lambda value: chr(int(value[1], 8)), fields[1]))
                 if resolved == mount or mount in resolved.parents:
                     return True
         return False
 
+    @staticmethod
+    def _wsl_execution_issue(
+        path: str, env: dict[str, str] | None = None,
+    ) -> str | None:
+        """Validate the selected WSL CLI and declared interpreter without spawning.
+
+        This is same-side admission, not a sandbox for the CLI's own commands.
+        Native Windows and non-WSL Linux retain their existing launch behavior.
+        """
+        if sys.platform != "linux" or not os.environ.get("WSL_DISTRO_NAME"):
+            return None
+        issue = "WSL Agent requires an available Linux-side CLI and interpreter; Windows interop or unverifiable tools are refused. Install the CLI inside the selected WSL distribution."
+        candidate = path
+        seen: set[str] = set()
+        for _ in range(4):
+            if not Path(candidate).is_absolute():
+                return issue
+            if AgentDiscovery._wsl_windows_executable(candidate):
+                return issue
+            try:
+                resolved = Path(candidate).resolve(strict=True)
+                if str(resolved) in seen or not resolved.is_file():
+                    return issue
+                seen.add(str(resolved))
+                with resolved.open("rb") as stream:
+                    header = stream.read(512)
+            except (OSError, RuntimeError):
+                return issue
+            if header.startswith(b"MZ"):
+                return issue
+            if not header.startswith(b"#!"):
+                return None
+            try:
+                line = header.split(b"\n", 1)[0][2:].decode("utf-8", errors="strict")
+                parts = shlex.split(line)
+            except (UnicodeError, ValueError):
+                return issue
+            if not parts or not Path(parts[0]).is_absolute():
+                return issue
+            interpreter = parts[0]
+            if Path(interpreter).name == "env":
+                if AgentDiscovery._wsl_windows_executable(interpreter):
+                    return issue
+                try:
+                    with Path(interpreter).open("rb") as stream:
+                        if stream.read(4) != b"\x7fELF":
+                            return issue
+                except OSError:
+                    return issue
+                arguments = parts[1:]
+                if arguments[:1] == ["-S"]:
+                    arguments = arguments[1:]
+                if not arguments or arguments[0].startswith("-") or "=" in arguments[0]:
+                    return issue
+                search_path = (env if env is not None else os.environ).get("PATH", "")
+                # Relative/empty PATH entries resolve against the child's cwd,
+                # not this host's cwd. Refuse rather than check another tool.
+                if not search_path or any(not Path(entry).is_absolute() for entry in search_path.split(os.pathsep)):
+                    return issue
+                interpreter = shutil.which(arguments[0], path=search_path)
+                if not interpreter:
+                    return issue
+            candidate = interpreter
+        return issue
+
     async def discover(self) -> list[DiscoveredAgent]:
         self._expand_path()
         # Probe bwrap support once at discovery time and log a clear warning
@@ -892,8 +961,9 @@ class AgentDiscovery:
             cmd = custom_path or spec["commands"][0]
             resolved = shutil.which(cmd)
             if resolved:
-                if self._wsl_windows_executable(resolved):
-                    logger.warning("Agent %s resolved only to a Windows executable inside WSL; skipping", agent_id)
+                issue = await asyncio.to_thread(self._wsl_execution_issue, resolved)
+                if issue:
+                    logger.warning("Agent %s has an unavailable Linux-side WSL toolchain; skipping", agent_id)
                     continue
                 version = await self._get_version(spec["detect"], resolved)
                 if version is None and "detect_alt" in spec:
@@ -1977,10 +2047,24 @@ def claude_base_env(
     return env
 
 
+def _mirror_skill_directory(source: Path, destination: Path) -> None:
+    if source.resolve() == destination.resolve():
+        return
+    try:
+        if destination.is_symlink() or destination.is_file():
+            destination.unlink()
+        elif destination.is_dir():
+            shutil.rmtree(destination)
+        if source.is_dir():
+            shutil.copytree(source, destination)
+    except OSError as exc:
+        logger.debug("Agent skill mirror skipped %s -> %s: %s", source, destination, exc)
+
+
 def prepare_claude_environment(
     sandbox_root: Path | None = None,
 ) -> dict[str, str]:
-    """Prepare an isolated Claude home and mirror stable configuration files.
+    """Prepare an isolated Claude home and mirror configuration and skills.
 
     When *sandbox_root* is given (per-task isolation via mkdtemp), uses that
     directory.  When None, falls back to the shared legacy path under ~/.forgexa.
@@ -1990,8 +2074,8 @@ def prepare_claude_environment(
     Claude use its default config, cache, and session locations under a
     writable task sandbox.
 
-    Mirror only stable authentication and settings files, including Claude
-    Code's current credential store. Runtime state such as session-env,
+    Mirror stable authentication, settings and installed skill bundles, including
+    Claude Code's current credential store. Runtime state such as session-env,
     projects, task locks, and history must never cross into an isolated daemon
     invocation. Do not set CLAUDE_CODE_DEBUG_LOGS_DIR:
     Claude Code 2.1.63 treats a directory supplied through that variable as
@@ -2028,6 +2112,9 @@ def prepare_claude_environment(
                 source, dest, exc,
             )
 
+    for relative_root in (Path(".claude/skills"), Path(".agents/skills")):
+        _mirror_skill_directory(Path.home() / relative_root, sandbox_root / relative_root)
+
     env = {
         "HOME": str(sandbox_root),
         "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": str(
@@ -2375,7 +2462,7 @@ def deepseek_harness_build_info(binary: str) -> dict:
     if result.returncode or not re.fullmatch(r"\d+\.\d+\.\d+", node_version) or parsed is None or not ((parsed[0] == 22 and parsed >= (22, 19, 0)) or parsed[0] >= 24):
         raise RuntimeError("DeepSeek Harness requires Node 22.19+ or Node 24+")
     digest = hashlib.sha256()
-    digest.update(f"{sys.platform}:{platform.machine()}:{platform.release()}:{node_version}:harness-policy-2".encode())
+    digest.update(f"{sys.platform}:{platform.machine()}:{platform.release()}:{node_version}:harness-policy-3".encode())
     extensions = [manifest.parent for manifest in (roots[0] / "node_modules" / "@deepseek-ai").glob("dsh*/package.json")]
     for root in sorted(set([*roots, *extensions])):
         files = [root / "package.json"] + sorted((root / "lib").rglob("*.js"))
@@ -2500,10 +2587,15 @@ def deepseek_harness_overlay(*, cwd: Path, credentials_path: Path, provider: str
         {"id": "tools", "config": {"mode": "native"}},
         {"id": "session-log-deepseek", "config": {"enabled": False}},
         {"id": "plugin-package-inventory-deepseek", "config": {"enabled": False}},
+        {"id": "skill-filesystem", "disabled": False, "config": {
+            "dshHome": str(Path(os.environ.get("DSH_HOME", str(Path.home() / ".dsh"))).expanduser().resolve()),
+            "watch": False,
+        }},
+        {"id": "tool-skill", "disabled": False},
     ]
     disabled = (
         "session-telemetry-otel", "hmr", "plugin-manager", "tool-plugin-manager",
-        "llm-pi-ai", "skill-filesystem", "tool-skill", "tool-subagent", "tool-subagent-fork",
+        "llm-pi-ai", "tool-subagent", "tool-subagent-fork",
         "tool-subagent-control", "tool-subagent-list-agents", "tool-workflow",
         "goal-round-driver", "command-goal", "tool-goal", "command-feedback", "tool-web",
     )
@@ -2748,7 +2840,7 @@ def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
         "MIMOCODE_PURE": "true",
         "MIMOCODE_DISABLE_DEFAULT_PLUGINS": "true",
         "MIMOCODE_DISABLE_PROJECT_CONFIG": "true",
-        "MIMOCODE_DISABLE_EXTERNAL_SKILLS": "true",
+        "MIMOCODE_DISABLE_EXTERNAL_SKILLS": "false",
         "MIMOCODE_DISABLE_LSP_DOWNLOAD": "true",
         "MIMOCODE_DISABLE_CLAUDE_CODE_MCP": "true",
         "MIMOCODE_DISABLE_AUTOUPDATE": "true",
@@ -2771,7 +2863,7 @@ def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
             },
             "external_directory": "deny",
             "task": "deny",
-            "skill": "deny",
+            "skill": {"*": "allow", "compose:*": "deny"},
             "webfetch": "deny",
             "websearch": "deny",
             "codesearch": "deny",
@@ -2886,16 +2978,16 @@ def build_qwen_command(
 ) -> list[str]:
     """Run Qwen Code headlessly with its user-managed local profile.
 
-    Qwen Code owns authentication, endpoint, and model configuration. Safe
-    mode disables project/user customizations for this Forgexa invocation
-    without replacing the user's native profile.
+    Qwen Code owns authentication, endpoint, model and skill discovery. The
+    environment policy disables hooks and MCP; CLI overrides disable extensions
+    without suppressing native skills or replacing the user's profile.
     """
     cmd = [
         binary,
         "--output-format", "stream-json",
         "--include-partial-messages",
         "--approval-mode", approval_mode,
-        "--safe-mode",
+        "--extensions", "",
     ]
     if sandbox:
         cmd.append("--sandbox")
@@ -2971,6 +3063,9 @@ def zcode_base_env(env: dict[str, str]) -> dict[str, str]:
             storage.chmod(0o700)
     except OSError as exc:
         raise RuntimeError(f"could not prepare isolated ZCode profile: {exc}") from exc
+    source_home = Path(source_env.get("HOME") or source_env.get("USERPROFILE") or str(Path.home())).expanduser()
+    for relative_root in (Path(".zcode/skills"), Path(".agents/skills")):
+        _mirror_skill_directory(source_home / relative_root, root / relative_root)
     safe_keys = {
         "PATH", "PATHEXT", "SystemRoot", "WINDIR", "COMSPEC",
         "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "LC_CTYPE", "TERM",
@@ -3073,9 +3168,9 @@ def zcode_build_verification_issue(binary: str | Path, env: dict[str, str] | Non
     return None
 
 
-ZCODE_ALLOWED_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write")
+ZCODE_ALLOWED_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Skill")
 ZCODE_DENIED_TOOLS = (
-    "Bash", "MCP", "Plugin", "Skill", "Task", "WebFetch", "WebSearch",
+    "Bash", "MCP", "Plugin", "Task", "WebFetch", "WebSearch",
 )
 
 
@@ -3152,11 +3247,10 @@ def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None
     return None
 
 
-_FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash")
+_FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash", "Skill")
 _FORGEXA_CODING_AGENT_DENIED_TOOLS = (
     "Agent",
     "Task",
-    "Skill",
     "SlashCommand",
     "WebFetch",
     "WebSearch",
@@ -3229,8 +3323,8 @@ def build_qoder_command(
     """Run Qoder CLI through its isolated headless stream-json protocol.
 
     Qoder receives model selection through its official ``QODER_MODEL``
-    environment variable. All settings sources stay disabled so user, project,
-    and local hooks, plugins, and skills cannot affect a Forgexa task.
+    environment variable. Settings sources stay disabled to isolate hooks and
+    plugins; installed skills remain available through the managed profile.
     """
     cmd = [
         binary,
@@ -3382,7 +3476,7 @@ def _link_qoder_profile_entry(
 
 
 def qoder_managed_profile_dir(env: dict[str, str] | None = None) -> Path:
-    """Create a stable Qoder profile containing only auth and model metadata."""
+    """Create a stable Qoder profile containing auth, model metadata and skills."""
     source_env = os.environ if env is None else env
     source_root = _qoder_source_profile_root(source_env)
     managed_root = _qoder_managed_profile_root(source_root)
@@ -3393,13 +3487,13 @@ def qoder_managed_profile_dir(env: dict[str, str] | None = None) -> Path:
     except OSError as exc:
         raise RuntimeError(f"could not create managed Qoder profile: {exc}") from exc
 
-    for name in (".auth", ".models", "installation_id"):
+    for name in (".auth", ".models", "installation_id", "skills"):
         _link_qoder_profile_entry(source_root, managed_root, name)
     return managed_root
 
 
 def qoder_base_env(env: dict[str, str]) -> dict[str, str]:
-    """Constrain Qoder while linking only user-managed auth and model metadata."""
+    """Constrain Qoder while preserving user-managed auth, model and skills."""
     env = dict(env)
     local_model = qoder_local_model(env)
     managed_profile = qoder_managed_profile_dir(env)
@@ -3425,9 +3519,8 @@ def qwen_base_env(env: dict[str, str]) -> dict[str, str]:
     """Return a constrained environment without replacing Qwen's local profile.
 
     Authentication, endpoint, and model selection remain entirely under the
-    user's Qwen Code configuration. The command's native ``--safe-mode`` flag
-    handles customization isolation; this function only disables telemetry for
-    the Forgexa-managed process.
+    user's Qwen Code configuration. A system override isolates executable
+    customizations without disabling installed skills.
     """
     env = dict(env)
     for key in (
@@ -3439,7 +3532,23 @@ def qwen_base_env(env: dict[str, str]) -> dict[str, str]:
         "QWEN_CODE_SYSTEM_SETTINGS_PATH",
     ):
         env.pop(key, None)
+    settings_dir = Path.home() / ".forgexa" / "qwen"
+    settings_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+    settings_path = settings_dir / "settings.json"
+    with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=settings_dir, delete=False) as temporary:
+        json.dump({
+            "disableAllHooks": True,
+            "mcp": {"excluded": ["*"], "serverCommand": ""},
+            "tools": {"discoveryCommand": "", "callCommand": ""},
+            "skills": {"disabledLevels": ["extension"]},
+        }, temporary)
+        temporary_path = Path(temporary.name)
+    try:
+        os.replace(temporary_path, settings_path)
+    finally:
+        temporary_path.unlink(missing_ok=True)
     env.update({
+        "QWEN_CODE_SYSTEM_SETTINGS_PATH": str(settings_path),
         "QWEN_USAGE_STATISTICS_ENABLED": "0",
         "QWEN_TELEMETRY_ENABLED": "0",
         "QWEN_TELEMETRY_LOG_PROMPTS": "0",

{forgexa_cli-1.62.3 → forgexa_cli-1.62.5}/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.3"
+DAEMON_VERSION = "1.62.5"
 
 
 def _detect_client_type() -> str:

{forgexa_cli-1.62.3 → forgexa_cli-1.62.5}/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.3 → forgexa_cli-1.62.5}/forgexa_cli.egg-info/PKG-INFO

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

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

{forgexa_cli-1.62.3 → forgexa_cli-1.62.5}/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"