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

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

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

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

{forgexa_cli-1.62.4 → 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.4 → 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.4"
+DAEMON_VERSION = "1.62.5"
 
 
 def _detect_client_type() -> str:

{forgexa_cli-1.62.4 → 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.4
+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.4 → forgexa_cli-1.62.5}/pyproject.toml

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