forgexa-cli 1.21.2__tar.gz → 1.21.4__tar.gz

{forgexa_cli-1.21.2 → forgexa_cli-1.21.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.21.2
+Version: 1.21.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.21.2 → forgexa_cli-1.21.4}/forgexa_cli/__init__.py

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

{forgexa_cli-1.21.2 → forgexa_cli-1.21.4}/forgexa_cli/autoupgrade.py

@@ -78,7 +78,7 @@ def _state_path() -> Path:
 
 
 def empty_state() -> dict:
-    return {"active": None, "last_failure": None, "last_success": None}
+    return {"active": None, "last_failure": None, "last_success": None, "last_skip": None}
 
 
 def read_state() -> dict:

{forgexa_cli-1.21.2 → forgexa_cli-1.21.4}/forgexa_cli/daemon.py

@@ -555,7 +555,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.21.2"
+DAEMON_VERSION = "1.21.4"
 
 
 def _detect_client_type() -> str:
@@ -771,6 +771,27 @@ class DiscoveredAgent:
     version: str
     invoke_modes: list[str]
     compatibility_level: str
+    min_version_ok: bool = True
+    version_warning: str = ""
+
+
+def _agent_dicts_for_wire(agents: "list[DiscoveredAgent]") -> list[dict]:
+    """Serialize discovered agents for the register/heartbeat wire payload.
+
+    Single source of truth for this shape so register(), the initial
+    heartbeat payload, and periodic heartbeat updates never drift apart.
+    """
+    return [
+        {
+            "agent_id": a.agent_id,
+            "version": a.version,
+            "invoke_modes": a.invoke_modes,
+            "compatibility_level": a.compatibility_level,
+            "min_version_ok": a.min_version_ok,
+            "version_warning": a.version_warning,
+        }
+        for a in agents
+    ]
 
 
 def _prepare_agent_command(command: list[str]) -> list[str]:
@@ -811,6 +832,71 @@ def _prepare_agent_command(command: list[str]) -> list[str]:
     return command
 
 
+def _windows_agent_needs_task_file_redirect(agent_command: str) -> bool:
+    """Return True when ``agent_command``'s prompt must be redirected through
+    a task file instead of being passed as a literal CLI argument.
+
+    Root cause: on Windows, ``.cmd``/``.bat`` launchers (the standard shim
+    format for globally-installed npm packages, e.g. Copilot CLI, Kimi Code)
+    are invoked through ``cmd.exe /c`` (see ``_prepare_agent_command``). The
+    command line handed to ``cmd.exe`` is built by ``subprocess.list2cmdline``,
+    which quotes arguments using the C-runtime/``CommandLineToArgvW``
+    convention -- but ``cmd.exe`` then RE-TOKENIZES that same string using its
+    own, different shell grammar before forwarding the remaining text to the
+    batch script (typically via ``%*``). Any cmd.exe metacharacter in the
+    prompt (``"``, ``&``, ``|``, ``^``, ``<``, ``>``, ``%``) survives the
+    first quoting pass but breaks the second, either splitting the prompt
+    into multiple arguments (observed as Copilot's "your prompt was not
+    quoted, so the extra words were treated as separate arguments" error) or,
+    in the worst case, allowing prompt content to inject additional shell
+    commands.  Native ``.exe`` targets are unaffected: a real EXE's C-runtime
+    argv parsing is exactly what ``list2cmdline`` guarantees. ``.ps1``
+    targets are also unaffected because ``_prepare_agent_command`` forwards
+    their arguments as a real argv list to ``powershell.exe -File``, not
+    through a second string-based shell.
+    """
+    if sys.platform != "win32":
+        return False
+    return Path(agent_command).suffix.lower() in {".cmd", ".bat"}
+
+
+def _redirect_prompt_through_task_file(
+    cwd: Path, prompt: str, task_id: str, agent_label: str,
+) -> tuple[str, Path | None]:
+    """Write ``prompt`` to a workspace-local file and return a short, fixed,
+    shell-metacharacter-free instruction telling the agent to read it instead.
+
+    Returns ``(effective_prompt, task_file)``. ``task_file`` is the path the
+    caller must delete after the run, or ``None`` if writing failed, in which
+    case ``effective_prompt`` falls back to the original ``prompt`` unchanged.
+    """
+    task_file = Path(cwd) / ".forgexa-task.md"
+    try:
+        task_file.write_text(prompt, encoding="utf-8")
+        # Prevent accidental git commit of this ephemeral file.
+        git_exclude = Path(cwd) / ".git" / "info" / "exclude"
+        if git_exclude.exists():
+            excl = git_exclude.read_text(encoding="utf-8", errors="replace")
+            if ".forgexa-task.md" not in excl:
+                git_exclude.write_text(
+                    excl.rstrip("\n") + "\n.forgexa-task.md\n", encoding="utf-8",
+                )
+        logger.debug(
+            "%s task %s: wrote %d-char prompt to .forgexa-task.md",
+            agent_label, task_id, len(prompt),
+        )
+        return (
+            "Read the file .forgexa-task.md for your complete task "
+            "specification. Follow all instructions in it exactly."
+        ), task_file
+    except Exception as exc:
+        logger.warning(
+            "%s task %s: could not write prompt file (%s); using prompt directly",
+            agent_label, task_id, exc,
+        )
+        return prompt, None
+
+
 def _agent_process_group_kwargs() -> dict[str, bool]:
     """Isolate agent process groups where the platform supports POSIX sessions."""
     # Windows cleanup uses taskkill /T, and starting cmd.exe with a new session
@@ -1112,11 +1198,6 @@ def _daemon_extract_claude_output(raw: str) -> str:
     return raw
 
 
-# OpenCode requires v1.4.0+ for --dangerously-skip-permissions (added 2026-04-08).
-# Without it, headless opencode run blocks on permission prompts and exits with code 1.
-_OPENCODE_MIN_VERSION = (1, 4, 0)
-
-
 def _parse_semver(v: str) -> "tuple[int, int, int] | None":
     """Parse a semver string into a comparable (major, minor, patch) tuple.
 
@@ -1133,6 +1214,40 @@ def _parse_semver(v: str) -> "tuple[int, int, int] | None":
     return None
 
 
+def _check_agent_min_version(agent_id: str, version: str, spec: dict) -> "tuple[bool, str]":
+    """Check a discovered agent's version against its registry minimum, if any.
+
+    Returns (min_version_ok, version_warning). version_warning is empty
+    whenever there's nothing to warn about: no minimum is defined for this
+    agent (``spec`` has no ``min_version`` key), the version string couldn't
+    be parsed (never treated as a hard failure -- unparseable versions are
+    skipped, not rejected, matching the pre-existing opencode behavior), or
+    the installed version already meets the minimum.
+
+    This is the single source of truth for per-agent minimum-version gating,
+    consumed by both AgentDiscovery.discover() (so `forgexa check` and the
+    daemon's own heartbeat can report incompatibility instantly, without
+    running a real task) and ProcessManager.run_agent() (a defense-in-depth
+    dispatch-time gate for any caller that bypasses discovery-time filtering).
+    """
+    min_version = spec.get("min_version")
+    if not min_version:
+        return True, ""
+    parsed = _parse_semver(version)
+    if parsed is None:
+        return True, ""
+    if parsed >= tuple(min_version):
+        return True, ""
+    min_str = ".".join(str(x) for x in min_version)
+    reason = spec.get("min_version_reason", "")
+    upgrade_hint = spec.get("upgrade_hint", f"upgrade the {agent_id} CLI")
+    warning = f"{agent_id} v{version} is older than the minimum supported v{min_str}+."
+    if reason:
+        warning += f" {reason}"
+    warning += f" Fix: {upgrade_hint}."
+    return False, warning
+
+
 def _daemon_extract_opencode_output(raw: str) -> str:
     """Extract text content from OpenCode JSONL output."""
     parts: list[str] = []
@@ -1494,6 +1609,13 @@ class AgentDiscovery:
             "env_path_override": "FACTORY_OPENCODE_PATH",
             "env_model_override": "FACTORY_OPENCODE_MODEL",
             "compatibility_level": "L2",
+            "min_version": (1, 4, 0),
+            "min_version_reason": (
+                "--dangerously-skip-permissions (required so headless runs "
+                "don't block on interactive permission prompts) was added "
+                "in v1.4.0 (2026-04-08)."
+            ),
+            "upgrade_hint": "opencode upgrade",
         },
         "gemini": {
             "commands": ["gemini"],
@@ -1508,6 +1630,14 @@ class AgentDiscovery:
             "invoke_modes": ["cli"],
             "env_path_override": "FACTORY_KIMI_PATH",
             "compatibility_level": "L2",
+            "min_version": (0, 18, 0),
+            "min_version_reason": (
+                "Non-interactive auto-approval via a bare -p <prompt> (no "
+                "--yolo/--auto) and the current on-disk auth/session layout "
+                "both assume Kimi Code v0.18.0+; older versions require "
+                "--yolo/--auto for auto-approval and use a different auth "
+                "storage layout."
+            ),
         },
         "copilot": {
             "commands": ["copilot"],
@@ -1652,12 +1782,20 @@ class AgentDiscovery:
                         agent_id, resolved,
                     )
                     continue
+                min_version_ok, version_warning = _check_agent_min_version(agent_id, version, spec)
+                if not min_version_ok:
+                    logger.warning(
+                        "Agent %s found at %s (v%s) but below minimum version: %s",
+                        agent_id, resolved, version, version_warning,
+                    )
                 available.append(DiscoveredAgent(
                     agent_id=agent_id,
                     command=resolved,
                     version=version,
                     invoke_modes=spec["invoke_modes"],
                     compatibility_level=spec["compatibility_level"],
+                    min_version_ok=min_version_ok,
+                    version_warning=version_warning,
                 ))
                 logger.info("Discovered agent: %s v%s (%s)", agent_id, version, resolved)
         return available
@@ -4240,6 +4378,22 @@ class ProcessManager:
         on_chunk: Any = None,
     ) -> TaskResult:
         """Execute an agent CLI and collect results."""
+        # Centralized, agent-agnostic version gate: AgentDiscovery.discover()
+        # already computed min_version_ok/version_warning against
+        # AGENT_REGISTRY[agent_id]["min_version"] (see _check_agent_min_version).
+        # Refuse to dispatch rather than letting a known-incompatible CLI
+        # invocation fail later with a confusing/unrelated error.
+        if not agent.min_version_ok:
+            logger.warning(
+                "Refusing to run task %s on agent '%s': %s",
+                task.task_id, agent.agent_id, agent.version_warning,
+            )
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=agent.version_warning,
+                failure_code="agent_version_incompatible",
+            )
+
         prompt = self._build_prompt(task)
         timeout = task.timeout_seconds or settings.AGENT_TIMEOUT
 
@@ -4854,36 +5008,14 @@ class ProcessManager:
         opencode runs do not share the same SQLite database, which causes
         'Failed to run the query PRAGMA wal_checkpoint(PASSIVE)' errors and
         exit code 1 when multiple tasks run simultaneously.
-        """
-        # --dangerously-skip-permissions was introduced in opencode v1.4.0 (2026-04-08).
-        # Older versions silently ignore the flag but then block on permission prompts
-        # in headless mode (no TTY), eventually exiting with code 1 after a long wait.
-        # Fail fast here so the error is immediately actionable.
-        _oc_ver = _parse_semver(agent.version)
-        if _oc_ver is None:
-            # Non-standard version string (e.g. 'unknown', 'latest') — skip version
-            # check rather than incorrectly rejecting a potentially valid agent.
-            logger.warning(
-                "Could not parse opencode version %r; skipping version check",
-                agent.version,
-            )
-        elif _oc_ver < _OPENCODE_MIN_VERSION:
-            _min_str = ".".join(str(x) for x in _OPENCODE_MIN_VERSION)
-            return TaskResult(
-                status="failed",
-                exit_code=-1,
-                stdout="",
-                stderr="",
-                error=(
-                    f"OpenCode {agent.version} is too old for headless execution. "
-                    f"Version {_min_str}+ is required: --dangerously-skip-permissions "
-                    f"(which auto-approves permission prompts in non-interactive mode) "
-                    f"was added in v{_min_str} on 2026-04-08. "
-                    f"Upgrade with: opencode upgrade"
-                ),
-                failure_code="agent_version_incompatible",
-            )
 
+        Version compatibility (opencode requires v1.4.0+ for
+        --dangerously-skip-permissions -- older versions silently ignore the
+        flag but then block on permission prompts in headless mode) is
+        checked centrally in ProcessManager.run_agent() before dispatch, via
+        AGENT_REGISTRY["opencode"]["min_version"] / _check_agent_min_version().
+        No need to re-check it here.
+        """
         cmd = [
             agent.command, "run",
             "--format", "json",
@@ -4975,11 +5107,30 @@ class ProcessManager:
                 ),
             )
 
-        cmd = [agent.command, "-p", prompt]
-        result = await self._run_cli(
-            cmd, cwd, timeout, task_id, on_chunk=on_chunk,
-            stream_stderr=True,
-        )
+        # Same Windows cmd.exe quoting/injection hazard as Copilot CLI (see
+        # _windows_agent_needs_task_file_redirect): Kimi's npm-installed
+        # kimi.cmd/.bat shim is invoked through cmd.exe, which can corrupt or
+        # split a prompt passed directly as a -p argument. Redirect through a
+        # task file whenever that launcher type is in play.
+        _effective_prompt = prompt
+        _task_file: Path | None = None
+        if _windows_agent_needs_task_file_redirect(agent.command):
+            _effective_prompt, _task_file = _redirect_prompt_through_task_file(
+                cwd, prompt, task_id, "Kimi Code",
+            )
+
+        cmd = [agent.command, "-p", _effective_prompt]
+        try:
+            result = await self._run_cli(
+                cmd, cwd, timeout, task_id, on_chunk=on_chunk,
+                stream_stderr=True,
+            )
+        finally:
+            if _task_file is not None:
+                try:
+                    _task_file.unlink(missing_ok=True)
+                except Exception:
+                    pass
 
         # ── Post-run: degarble Kimi Code 0.18.0 error messages ───────────────
         # Kimi Code 0.18.0 has a bug where it streams 404/auth error text
@@ -5349,39 +5500,24 @@ class ProcessManager:
 
         # On Windows, batch/cmd wrappers (e.g. copilot.BAT from the VS Code
         # Copilot Chat extension) invoke cmd.exe when run via CreateProcess.
-        # cmd.exe has an ~8191-char command-line limit; long multi-line prompts
-        # are silently truncated so the agent runs but never sees the output
-        # file instructions — producing no required deliverables.
-        # Fix: write the full prompt to a workspace-local file and pass a short
-        # single-line read-instruction via -p to stay under the limit.
+        # This causes two independent problems for a prompt passed as a
+        # literal -p argument: (1) cmd.exe's ~8191-char command-line limit
+        # silently truncates long multi-line prompts, and (2) cmd.exe
+        # re-tokenizes the already-quoted command line using its own shell
+        # grammar, so any cmd.exe metacharacter in the prompt (", &, |, ^, <,
+        # >, %) corrupts the quoting boundary and splits the prompt into
+        # multiple arguments -- surfaced by Copilot as "your prompt was not
+        # quoted, so the extra words were treated as separate arguments".
+        # See _windows_agent_needs_task_file_redirect for the full mechanism.
+        # Fix: write the full prompt to a workspace-local file and pass a
+        # short, fixed, metacharacter-free read-instruction via -p instead --
+        # for every prompt on this launcher type, not just multi-line ones.
         _task_file: Path | None = None
         _effective_prompt = prompt
-        if sys.platform == "win32" and "\n" in prompt:
-            _task_file = Path(cwd) / ".forgexa-task.md"
-            try:
-                _task_file.write_text(prompt, encoding="utf-8")
-                # Prevent accidental git commit of this ephemeral file
-                _git_exclude = Path(cwd) / ".git" / "info" / "exclude"
-                if _git_exclude.exists():
-                    _excl = _git_exclude.read_text(encoding="utf-8", errors="replace")
-                    if ".forgexa-task.md" not in _excl:
-                        _git_exclude.write_text(
-                            _excl.rstrip("\n") + "\n.forgexa-task.md\n", encoding="utf-8",
-                        )
-                _effective_prompt = (
-                    "Read the file .forgexa-task.md for your complete task "
-                    "specification. Follow all instructions in it exactly."
-                )
-                logger.debug(
-                    "Copilot task %s: wrote %d-char prompt to .forgexa-task.md",
-                    task_id, len(prompt),
-                )
-            except Exception as _tf_err:
-                logger.warning(
-                    "Copilot task %s: could not write prompt file (%s); using -p directly",
-                    task_id, _tf_err,
-                )
-                _task_file = None
+        if _windows_agent_needs_task_file_redirect(agent.command):
+            _effective_prompt, _task_file = _redirect_prompt_through_task_file(
+                cwd, prompt, task_id, "Copilot",
+            )
 
         cmd += ["-C", str(cwd), "-p", _effective_prompt]
         cmd = _prepare_agent_command(cmd)
@@ -7110,15 +7246,7 @@ class ServerConnection:
         """Register this daemon with the server."""
         self._agents = agents
         self._max_concurrent_cache = max_concurrent
-        agent_dicts = [
-            {
-                "agent_id": a.agent_id,
-                "version": a.version,
-                "invoke_modes": a.invoke_modes,
-                "compatibility_level": a.compatibility_level,
-            }
-            for a in agents
-        ]
+        agent_dicts = _agent_dicts_for_wire(agents)
         async def _register_once():
             return await self.client.post(
                 f"{self.server_url}/api/v1/runtimes/register",
@@ -7192,15 +7320,7 @@ class ServerConnection:
         )
         self.heartbeat._on_success = _on_auth_success
         self.heartbeat._on_auth_failure = _on_auth_failure
-        self.heartbeat.update(0, [
-            {
-                "agent_id": a.agent_id,
-                "version": a.version,
-                "invoke_modes": a.invoke_modes,
-                "compatibility_level": a.compatibility_level,
-            }
-            for a in agents
-        ])
+        self.heartbeat.update(0, _agent_dicts_for_wire(agents))
         self.poller = TaskPoller(
             self.client, self.server_url, self.runtime_id, poll_interval,
         )
@@ -11778,15 +11898,7 @@ class RuntimeDaemon:
             return f"Push failed: {e}"
 
     def _agents_as_dicts(self) -> list[dict]:
-        return [
-            {
-                "agent_id": a.agent_id,
-                "version": a.version,
-                "invoke_modes": a.invoke_modes,
-                "compatibility_level": a.compatibility_level,
-            }
-            for a in self.agents
-        ]
+        return _agent_dicts_for_wire(self.agents)
 
     async def _cleanup_stale_tmp_dirs(self) -> None:
         """Remove stale Copilot/Claude temp dirs from prior OOM-killed daemon runs.