forgexa-cli 1.56.3__tar.gz → 1.57.0__tar.gz

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.56.3
+Version: 1.57.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.56.3 → forgexa_cli-1.57.0}/forgexa_cli/__init__.py

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

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/forgexa_cli/agent_core.py

@@ -2386,6 +2386,39 @@ _UNVERIFIED_AGENT_LIVE_GATE_REASONS = {
     ),
 }
 
+AGENT_LIVE_VERIFIED_FILE = Path.home() / ".forgexa" / "agent-live-verified"
+
+
+def agent_live_gate_approved(agent_id: str, env: dict[str, str] | None = None) -> bool:
+    """Whether an operator recorded a live-acceptance pass for this agent.
+
+    Fail-closed by default: the gate only opens through an explicit
+    ``forgexa agent approve-live <id>`` (persistent file, readable by
+    GUI-launched runtimes) or the FORGEXA_AGENT_LIVE_VERIFIED env var —
+    both mean a human actually ran the live start/resume/cancel/isolation
+    acceptance against a real account/build and accepted the result.
+    Agents without a live gate entry are NOT approved here: their gate is
+    the class-level ``integration_verified`` flag, and returning True
+    would silently disarm it for any driver marked unverified.
+    """
+    if agent_id.lower() not in _UNVERIFIED_AGENT_LIVE_GATE_REASONS:
+        return False
+    source_env = os.environ if env is None else env
+    verified = {
+        value.strip().lower()
+        for value in source_env.get("FORGEXA_AGENT_LIVE_VERIFIED", "").split(",")
+        if value.strip()
+    }
+    try:
+        lines = AGENT_LIVE_VERIFIED_FILE.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        lines = []
+    for line in lines:
+        value = line.split("#", 1)[0].strip()
+        if value:
+            verified.add(value.lower())
+    return agent_id.lower() in verified
+
 
 def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None:
     """Return a fail-closed build/live-acceptance gate for local agents."""
@@ -2393,7 +2426,15 @@ def agent_execution_verification_issue(agent_id: str, binary: str) -> str | None
         build_issue = zcode_build_verification_issue(binary)
         if build_issue:
             return build_issue
-    return _UNVERIFIED_AGENT_LIVE_GATE_REASONS.get(agent_id)
+    if agent_live_gate_approved(agent_id):
+        return None
+    reason = _UNVERIFIED_AGENT_LIVE_GATE_REASONS.get(agent_id)
+    if reason:
+        return (
+            f"{reason}; run `forgexa agent approve-live {agent_id}` after "
+            "completing the acceptance checklist"
+        )
+    return None
 
 
 _FORGEXA_CODING_AGENT_TOOLS = ("Read", "Glob", "Grep", "Edit", "Write", "Bash")

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/forgexa_cli/daemon.py

@@ -1150,7 +1150,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.56.3"
+DAEMON_VERSION = "1.57.0"
 
 
 def _detect_client_type() -> str:
@@ -1215,6 +1215,38 @@ logging.basicConfig(
 # Routine poll/heartbeat requests otherwise consume the entire 500-line remote
 # log tail in about 20 minutes, hiding the task failure operators need to see.
 logging.getLogger("httpx").setLevel(logging.WARNING)
+
+
+def _pid_looks_like_forgexa_daemon(pid: int) -> bool:
+    """Best-effort identity check before signalling a lock-file PID.
+
+    Reads the process cmdline (Linux /proc, macOS `ps`) and accepts the PID
+    only when it mentions this daemon. Unknown/unreadable identity returns
+    False — the conservative direction is leaving the stale lock to the
+    operator, never killing an unrelated reused PID (audit AGT-05).
+    """
+    if pid <= 0:
+        return False
+    if pid == os.getpid():
+        return True
+    try:
+        cmdline = ""
+        try:
+            with open(f"/proc/{pid}/cmdline", "rb") as fh:
+                cmdline = fh.read().replace(b"\0", b" ").decode("utf-8", "replace")
+        except OSError:
+            import subprocess as _sp
+
+            result = _sp.run(
+                ["ps", "-p", str(pid), "-o", "command="],
+                capture_output=True, text=True, timeout=5,
+            )
+            cmdline = result.stdout or ""
+        lowered = cmdline.lower()
+        return "forgexa" in lowered or "daemon.py" in lowered
+    except Exception:
+        return False
+
 logger = logging.getLogger("daemon")
 logger.info("Daemon log: %s", DAEMON_LOG_PATH)
 
@@ -10916,8 +10948,22 @@ class RuntimeDaemon:
             # Lock held by another process — try to read its PID and kill it
             try:
                 old_pid = int(lock_path.read_text().strip())
-                logger.warning("Another daemon is running (PID %d). Sending SIGTERM...", old_pid)
-                os.kill(old_pid, signal.SIGTERM)
+                if not _pid_looks_like_forgexa_daemon(old_pid):
+                    # AGT-05 (audit): a stale PID reused by an unrelated
+                    # process must never be signalled — verify identity from
+                    # the process cmdline before killing (mirrors the Rust
+                    # daemon manager's check).
+                    logger.error(
+                        "Lock file names PID %d but it is not a Forgexa daemon — "
+                        "refusing to signal it; remove the stale lock manually",
+                        old_pid,
+                    )
+                    old_pid = 0
+                if old_pid:
+                    logger.warning("Another daemon is running (PID %d). Sending SIGTERM...", old_pid)
+                    os.kill(old_pid, signal.SIGTERM)
+                if not old_pid:
+                    raise ValueError("no verified daemon PID")
                 # Wait up to 5 seconds for it to exit
                 for _ in range(50):
                     try:

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/forgexa_cli/main.py

@@ -3612,6 +3612,48 @@ def cmd_zcode_approve_build(args: argparse.Namespace) -> None:
     print("running daemons and desktop sidecars pick this up on their next probe (no restart needed)")
 
 
+def cmd_agent_approve_live(args: argparse.Namespace) -> None:
+    from datetime import datetime, timezone
+
+    from . import agent_core
+
+    agent_id = args.agent_id.strip().lower()
+    gated = set(agent_core._UNVERIFIED_AGENT_LIVE_GATE_REASONS)
+    if agent_id not in gated:
+        print(
+            f"error: unknown gated agent '{agent_id}'; gated agents: {', '.join(sorted(gated))}",
+            file=sys.stderr,
+        )
+        return
+    path = agent_core.AGENT_LIVE_VERIFIED_FILE
+    existing = ""
+    try:
+        existing = path.read_text(encoding="utf-8")
+    except OSError:
+        pass
+    approved = {
+        line.split("#", 1)[0].strip().lower()
+        for line in existing.splitlines() if line.split("#", 1)[0].strip()
+    }
+    if agent_id in approved:
+        print(f"already live-verified: {agent_id}")
+        print(f"allowlist file: {path}")
+        return
+    who = getpass.getuser()
+    when = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    suffix = "" if (not existing or existing.endswith("\n")) else "\n"
+    path.write_text(
+        existing + suffix
+        + f"{agent_id}  # live gate accepted by {who} at {when} via `forgexa agent approve-live`\n",
+        encoding="utf-8",
+    )
+    print(f"live gate approved for agent: {agent_id}")
+    print(f"accepted by: {who} at {when}")
+    print(f"written to: {path}")
+    print("only do this after completing the live start/resume/cancel/isolation acceptance checklist")
+
+
 def main() -> None:
     global _SERVER_URL_OVERRIDE, _output_format
 
@@ -3841,6 +3883,19 @@ def main() -> None:
         help="Path to the zcode binary (default: $FACTORY_ZCODE_PATH or `zcode` on PATH)",
     )
 
+    # agent
+    agent_p = sub.add_parser("agent", help="Agent gate management")
+    agent_sub = agent_p.add_subparsers(dest="agent_cmd")
+    agent_approve_live_p = agent_sub.add_parser(
+        "approve-live",
+        help="Record that an agent passed its live acceptance gate "
+             "(opens the fail-closed live gate for daemon dispatch and desktop probes)",
+    )
+    agent_approve_live_p.add_argument(
+        "agent_id", metavar="AGENT_ID",
+        help="Gated agent id (e.g. trae, zcode)",
+    )
+
     # runtimes
     rt_p = sub.add_parser("runtimes", help="Runtime management")
     rt_sub = rt_p.add_subparsers(dest="rt_cmd")
@@ -3973,6 +4028,9 @@ def main() -> None:
         "zcode": lambda a: {
             "approve-build": cmd_zcode_approve_build,
         }.get(a.zcode_cmd, lambda _: zcode_p.print_help())(a),
+        "agent": lambda a: {
+            "approve-live": cmd_agent_approve_live,
+        }.get(a.agent_cmd, lambda _: agent_p.print_help())(a),
         "runtimes": lambda a: {
             "list": cmd_runtimes_list,
         }.get(a.rt_cmd, lambda _: rt_p.print_help())(a),

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/forgexa_cli/zcode_protocol.py

@@ -278,7 +278,18 @@ class ZCodeProtocolSession:
         text = ""
         usage: dict[str, int] = {}
         if terminal.status == "success":
-            text, usage = await self._fetch_turn_transcript(terminal.turn_id)
+            try:
+                text, usage = await self._fetch_turn_transcript(terminal.turn_id)
+            except ZCodeProtocolError as exc:
+                # AGT-06 (audit): the work already landed on disk — a
+                # transcript read-back failure must not flip a terminal
+                # success into a protocol failure (and a pointless re-run).
+                # Degrade to empty text with the reason surfaced.
+                logger.warning(
+                    "zcode transcript read-back failed for session %s: %s",
+                    self.session_id, exc,
+                )
+                text = ""
         return ZCodeTurnResult(
             status=terminal.status,
             session_id=self.session_id or "",
@@ -297,6 +308,7 @@ class ZCodeProtocolSession:
             return "", {}
         texts: list[str] = []
         totals = {"input_tokens": 0, "output_tokens": 0}
+        turn_known = isinstance(turn_id, str) and bool(turn_id)
         for message in messages:
             if not isinstance(message, dict):
                 continue
@@ -305,7 +317,14 @@ class ZCodeProtocolSession:
                 continue
             anchor = info.get("anchor") if isinstance(info.get("anchor"), dict) else {}
             message_turn = anchor.get("turnId")
-            if turn_id and isinstance(message_turn, str) and message_turn != turn_id:
+            if turn_known and isinstance(message_turn, str) and message_turn != turn_id:
+                continue
+            if not turn_known and message_turn is not None:
+                # AGT-06 (audit): the ack/op-event channel never yielded a
+                # turnId — attributing the whole resumed session's assistant
+                # history to this turn would pollute the answer. Only
+                # un-anchored messages (the current in-flight exchange) may
+                # be attributed; anchored history belongs to earlier turns.
                 continue
             parts = message.get("parts") if isinstance(message.get("parts"), list) else []
             for part in parts:

{forgexa_cli-1.56.3 → forgexa_cli-1.57.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.56.3
+Version: 1.57.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.56.3 → forgexa_cli-1.57.0}/pyproject.toml

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