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

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

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

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

{forgexa_cli-1.62.4 → forgexa_cli-1.63.0}/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:
@@ -1239,12 +1309,14 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
     (npm, yarn, ssh, git, etc.) spawned by the agent stay alive, keep pipes
     open, and exhaust system resources.  ``os.killpg`` sends SIGKILL to the
     whole process group, reliably cleaning up all descendants.
+    Owned agents start a new session, so their PID remains the process-group
+    ID even after the leader exits.
     """
     try:
         if sys.platform != "win32":
             import signal as _signal
             try:
-                os.killpg(os.getpgid(proc.pid), _signal.SIGKILL)
+                os.killpg(proc.pid, _signal.SIGKILL)
             except (ProcessLookupError, PermissionError, OSError):
                 pass
         else:
@@ -1252,6 +1324,7 @@ def _kill_proc(proc: asyncio.subprocess.Process) -> None:
             _subprocess.run(
                 ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
                 capture_output=True,
+                timeout=5,
                 **_agent_process_group_kwargs(),
             )
     except Exception:
@@ -1977,10 +2050,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 +2077,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 +2115,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 +2465,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-4".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 +2590,20 @@ 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},
+        {"id": "tool-subagent", "disabled": False, "config": {
+            "provider": "spawn", "enableRunInBackground": False,
+            "backgroundMode": "one-shot", "maxDepth": 1,
+            "modelSelectionSettings": 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-fork",
         "tool-subagent-control", "tool-subagent-list-agents", "tool-workflow",
         "goal-round-driver", "command-goal", "tool-goal", "command-feedback", "tool-web",
     )
@@ -2748,7 +2848,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",
@@ -2770,8 +2870,8 @@ def mimo_base_env(env: dict[str, str]) -> dict[str, str]:
                 "git * reset --hard*": "deny",
             },
             "external_directory": "deny",
-            "task": "deny",
-            "skill": "deny",
+            "task": "allow",
+            "skill": {"*": "allow", "compose:*": "deny"},
             "webfetch": "deny",
             "websearch": "deny",
             "codesearch": "deny",
@@ -2886,16 +2986,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 +3071,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 +3176,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", "Agent", "Task")
 ZCODE_DENIED_TOOLS = (
-    "Bash", "MCP", "Plugin", "Skill", "Task", "WebFetch", "WebSearch",
+    "Bash", "MCP", "Plugin", "WebFetch", "WebSearch",
 )
 
 
@@ -3152,11 +3255,8 @@ 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", "Agent", "Task")
 _FORGEXA_CODING_AGENT_DENIED_TOOLS = (
-    "Agent",
-    "Task",
-    "Skill",
     "SlashCommand",
     "WebFetch",
     "WebSearch",
@@ -3229,8 +3329,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 +3482,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 +3493,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 +3525,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 +3538,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",
@@ -3546,9 +3661,10 @@ def build_copilot_command(
 
     ``prompt_via_stdin`` omits ``-p`` so the caller pipes the prompt into
     stdin instead - verified live on CLI 1.0.86, where piped stdin is a full
-    non-interactive prompt source.  The host uses it when the argv form would
-    exceed the platform command-line limit (inlined attachments can push the
-    prompt past Windows' 32k-char CreateProcess ceiling).
+    non-interactive prompt source.  The daemon uses it for native launchers
+    to avoid single-argument and total command-line limits; Windows batch
+    wrappers retain task-file redirection.  The host uses it when the argv
+    form would exceed the platform command-line limit.
     """
     cmd = [
         binary,

{forgexa_cli-1.62.4 → forgexa_cli-1.63.0}/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.63.0"
 
 
 def _detect_client_type() -> str:
@@ -6525,10 +6525,11 @@ class ProcessManager:
         _last_activity_at: list[float] = [time.monotonic()]
 
         # Write prompt and close stdin so the agent knows input is done.
-        if stdin_input and proc.stdin:
+        if proc.stdin:
             try:
-                proc.stdin.write(stdin_input)
-                await proc.stdin.drain()
+                if stdin_input:
+                    proc.stdin.write(stdin_input)
+                    await proc.stdin.drain()
             except Exception:
                 pass
             proc.stdin.close()
@@ -7668,7 +7669,8 @@ class ProcessManager:
         explicitly configured supported token environment variable.
 
         Flags:
-          -p / --prompt          Non-interactive prompt (exits after completion).
+          stdin                 Full non-interactive prompt, avoiding argv limits.
+          -p / --prompt          Short task-file instruction for Windows wrappers.
           --output-format json   JSONL stream of session events.
           --allow-all            Grant all tool + path + URL permissions required
                                  for autonomous file-editing tasks.
@@ -7768,11 +7770,13 @@ class ProcessManager:
             _effective_prompt, _task_file = _redirect_prompt_through_task_file(
                 cwd, prompt, task_id, "Copilot",
             )
+        _stdin_input = None if _task_file is not None else prompt.encode("utf-8")
 
         cmd = agent_core.build_copilot_command(
             agent.command,
             cwd=cwd,
             prompt=_effective_prompt,
+            prompt_via_stdin=_stdin_input is not None,
             model=model_override,
             reasoning=reasoning if not _retry_without_effort else None,
             disable_builtin_mcps=disable_builtin_mcps,
@@ -7786,9 +7790,20 @@ class ProcessManager:
         # reproduce failures manually and diagnose CLI version incompatibilities.
         _cmd_display = " ".join(
             f'"{a}"' if " " in a else a
-            for a in cmd[:-1]  # omit the -p value (potentially huge/sensitive)
-        ) + ' -p "<prompt>"'
-        logger.debug("Copilot invocation for task %s: %s", task_id, _cmd_display)
+            for a in (cmd if _stdin_input is not None else cmd[:-1])
+        )
+        if _stdin_input is None:
+            _cmd_display += ' "<prompt>"'
+        logger.debug(
+            "Copilot invocation for task %s: %s (prompt via %s)",
+            task_id, _cmd_display, "stdin" if _stdin_input is not None else "task file",
+        )
+        logger.info(
+            "Copilot task %s prompt transport: %s (%d UTF-8 bytes)",
+            task_id,
+            "stdin" if _stdin_input is not None else "task file",
+            len(_stdin_input) if _stdin_input is not None else len(prompt.encode("utf-8")),
+        )
 
         # On Windows, CREATE_NO_WINDOW ensures GetConsoleWindow() returns NULL for
         # the child process, even when the parent (daemon or Tauri app) has a console
@@ -7796,9 +7811,9 @@ class ProcessManager:
         # check via GetConsoleWindow(): if a console window is visible, it uses only
         # the first line of -p as a brief context note and reports "No task was
         # provided" for the rest of the prompt — silently discarding the full task.
-        # stdin=DEVNULL (below) covers the primary check (GetConsoleMode on stdin);
+        # A pipe or DEVNULL covers the primary check (GetConsoleMode on stdin);
         # CREATE_NO_WINDOW covers this secondary check so Copilot always sees a fully
-        # headless environment and processes -p as the complete task specification.
+        # headless environment and processes the complete task specification.
         proc: asyncio.subprocess.Process | None = None
 
         async def _terminate_copilot_process(
@@ -7817,18 +7832,11 @@ class ProcessManager:
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                # stdin=DEVNULL is critical on Windows.
-                # Without it, the child process inherits the parent daemon's stdin.
-                # On Windows, the daemon often has a real console handle on stdin
-                # (e.g. from a CMD/PowerShell window or the Desktop app's console).
-                # Copilot CLI detects this via GetConsoleMode(GetStdHandle(STD_INPUT))
-                # and enters interactive/session-check mode, ignoring -p as a task:
-                # it checks the session todo table (empty), reports "no tracked work
-                # items", and waits for user input instead of executing the task.
-                # On Linux/macOS (daemon as service), stdin is typically /dev/null so
-                # the bug doesn't manifest.  Explicit DEVNULL ensures non-interactive
-                # mode on all platforms, matching the intended headless operation.
-                stdin=asyncio.subprocess.DEVNULL,
+                stdin=(
+                    asyncio.subprocess.PIPE
+                    if _stdin_input is not None
+                    else asyncio.subprocess.DEVNULL
+                ),
                 cwd=str(cwd),
                 env=env,
                 limit=100 * 1024 * 1024,
@@ -7836,7 +7844,7 @@ class ProcessManager:
             )
             self.active_processes[task_id] = proc
             stdout, stderr, returncode = await self._stream_process(
-                proc, None, timeout, task_id, on_chunk,
+                proc, _stdin_input, timeout, task_id, on_chunk,
                 workspace_path=cwd,
                 stream_stderr=stream_stderr,
             )

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

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

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