forgexa-cli 1.8.3__tar.gz → 1.8.4__tar.gz

{forgexa_cli-1.8.3 → forgexa_cli-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.8.3
+Version: 1.8.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.8.3 → forgexa_cli-1.8.4}/forgexa_cli/__init__.py

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

{forgexa_cli-1.8.3 → forgexa_cli-1.8.4}/forgexa_cli/daemon.py

@@ -332,7 +332,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.8.3"
+DAEMON_VERSION = "1.8.4"
 
 
 def _detect_client_type() -> str:
@@ -756,6 +756,14 @@ class AgentDiscovery:
             resolved = shutil.which(cmd)
             if resolved:
                 version = await self._get_version(spec["detect"])
+                if version is None:
+                    # Binary found but version check failed — it is a stub or
+                    # not properly installed (e.g. copilot prompts to install).
+                    logger.warning(
+                        "Agent %s found at %s but version check failed — skipping",
+                        agent_id, resolved,
+                    )
+                    continue
                 available.append(DiscoveredAgent(
                     agent_id=agent_id,
                     command=resolved,
@@ -766,18 +774,43 @@ class AgentDiscovery:
                 logger.info("Discovered agent: %s v%s (%s)", agent_id, version, resolved)
         return available
 
-    async def _get_version(self, detect_cmd: str) -> str:
+    async def _get_version(self, detect_cmd: str) -> str | None:
+        """Run <detect_cmd> and return the first line of output as a version string.
+
+        Returns ``None`` if the command exits with a non-zero code, times out,
+        or produces output that doesn't look like a version number (e.g. an
+        interactive install prompt).  Callers should treat ``None`` as
+        "binary found but not functional".
+        """
+        import re
         try:
             parts = detect_cmd.split()
             proc = await asyncio.create_subprocess_exec(
                 *parts,
+                stdin=asyncio.subprocess.DEVNULL,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
-            return stdout.decode().strip().split("\n")[0][:100]
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=10)
+            if proc.returncode != 0:
+                return None
+            output = stdout.decode().strip().split("\n")[0][:100]
+            if not output:
+                # Some tools write their version to stderr (e.g. some Node CLIs)
+                output = stderr.decode().strip().split("\n")[0][:100]
+            # Reject non-version output such as interactive install prompts.
+            # A valid version string contains a digit sequence like 1.2.3 or v1.2.
+            # Use re.search so we match versions embedded in text like:
+            #   'Kimi Code 1.0.0', '@openai/codex 0.1.x', 'GitHub Copilot 1.2.3'
+            if not re.search(r'v?\d+[.\d]', output):
+                logger.warning(
+                    "Version check for %r returned unexpected output: %r — treating as not available",
+                    detect_cmd, output,
+                )
+                return None
+            return output
         except Exception:
-            return "unknown"
+            return None
 
     @staticmethod
     async def _probe_bwrap_support() -> None:
@@ -4647,9 +4680,12 @@ class RuntimeDaemon:
                 timeout=10,
             )
 
-            # 1. Select agent — normalize legacy aliases to canonical IDs
+            # 1. Select agent — normalize legacy aliases to canonical IDs.
+            # When no agent_override is specified (empty/None), pass an empty
+            # string so _select_agent falls through to its "any available L3
+            # agent" logic instead of hard-failing on the 'claude' default.
             _AGENT_ALIASES = {"claude": "claude", "kimi": "kimi"}
-            agent_type = _AGENT_ALIASES.get(agent_override or "", agent_override or "claude")
+            agent_type = _AGENT_ALIASES.get(agent_override or "", agent_override or "")
             agent = self._select_agent(agent_type, [])
             if not agent:
                 _INSTALL_HINTS = {
@@ -4679,7 +4715,11 @@ class RuntimeDaemon:
             full_prompt = f"{system_prompt}\n\n{user_prompt}" if system_prompt else user_prompt
             fake_task = TaskInfo(
                 task_id=job_id,
-                graph_id="",
+                # Use job_id as graph_id so workspace_key is non-empty.
+                # If graph_id="" then workspace_key="" and ws_path == project_dir
+                # (Python: Path("x") / "" == Path("x")), causing git clone to
+                # fail with "destination path already exists" on the second run.
+                graph_id=job_id,
                 node_type="ai_job",
                 agent_type=agent_type,
                 input_prompt=full_prompt,
@@ -4704,40 +4744,86 @@ class RuntimeDaemon:
                 timeout=10,
             )
 
-            # 3. Run agent with prompt
+            # 3. Run agent with prompt — stream output lines back to server in
+            # real-time so the UI black box shows agent activity instead of
+            # staying empty for the entire (potentially long) run.
             _line_buffer: list[str] = []
+            _chunk_state = {"sent_count": 0, "last_flush": time.monotonic()}
+
+            async def _flush_output_to_server():
+                pending = _line_buffer[_chunk_state["sent_count"]:]
+                if not pending:
+                    return
+                try:
+                    await conn.client.post(
+                        f"{reporter_url}/progress",
+                        json={"output_lines": pending, "agent_id": agent.agent_id},
+                        timeout=5,
+                    )
+                except Exception:
+                    pass  # never let streaming errors affect agent execution
+                _chunk_state["sent_count"] += len(pending)
+                _chunk_state["last_flush"] = time.monotonic()
 
             async def on_chunk(lines: list[str]):
                 _line_buffer.extend(lines)
+                now = time.monotonic()
+                pending_count = len(_line_buffer) - _chunk_state["sent_count"]
+                # Flush every 10 new lines or every 8 seconds, whichever first
+                if pending_count >= 10 or (now - _chunk_state["last_flush"]) >= 8.0:
+                    await _flush_output_to_server()
 
             result = await self.process_manager.run_agent(
                 agent, fake_task, workspace_path, on_chunk=on_chunk,
             )
+            # Flush any remaining buffered lines after agent finishes
+            await _flush_output_to_server()
 
             # 4. Auto-commit if successful
+            input_ctx = aj.get("input_context", {})
             git_info = {}
             if result.status == "success" and result.files_changed:
                 git_info = await self._auto_commit(workspace_path, fake_task)
 
             # 5. Report completion
-            output_content = result.stdout[-20000:] if result.stdout else ""
+            # For deliverables: allow up to 200K chars (full document); others: last 20K
+            max_content = 200000 if task_type == "deliverable_generate" else 20000
+            output_content = (result.stdout or "")[-max_content:] if result.stdout else ""
             scripts: dict = {}
 
-            # Try to extract per-scenario scripts from output
-            scenario_ids = aj.get("input_context", {}).get("scenario_ids", [])
+            scenario_ids = input_ctx.get("scenario_ids", [])
             if scenario_ids and output_content:
-                # Simple heuristic: if output is a single script, map it to first scenario
-                # Daemon-generated scripts may be multiple files in workspace
+                # Primary: extract scripts using structured SCRIPT_START/END markers
+                # inserted by poll_ai_jobs into the multi-scenario prompt.
+                import re as _re
                 for sid in scenario_ids:
-                    # Check if daemon wrote test files to workspace
-                    import glob
-                    test_files = glob.glob(str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"), recursive=True)
-                    if test_files:
-                        try:
-                            with open(test_files[0], "r") as f:
-                                scripts[sid] = f.read()
-                        except Exception:
-                            pass
+                    pattern = (
+                        r"##\s*SCRIPT_START::" + _re.escape(sid)
+                        + r"\s*\n(.*?)\n##\s*SCRIPT_END::" + _re.escape(sid)
+                    )
+                    m = _re.search(pattern, output_content, _re.DOTALL)
+                    if m:
+                        scripts[sid] = m.group(1).strip()
+
+                # Fallback: if no markers found but only one scenario, treat
+                # the entire output as that scenario's script.
+                if not scripts and len(scenario_ids) == 1:
+                    scripts[scenario_ids[0]] = output_content.strip()
+
+                # Fallback: check workspace for test files named after scenario
+                if not scripts:
+                    import glob as _glob
+                    for sid in scenario_ids:
+                        test_files = _glob.glob(
+                            str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"),
+                            recursive=True,
+                        )
+                        if test_files:
+                            try:
+                                with open(test_files[0], "r") as f:
+                                    scripts[sid] = f.read()
+                            except Exception:
+                                pass
 
             complete_payload = {
                 "status": "success" if result.status == "success" else "failed",
@@ -5349,12 +5435,18 @@ class RuntimeDaemon:
         self, workspace_path: Path, default_branch: str, task: TaskInfo,
         project_key: str = "default",
     ):
-        """Rebase the current branch onto ``origin/{default_branch}``.
-
-        Strategy (3-tier):
-          1. ``git rebase origin/{default_branch}`` — cleanest; linear history.
-          2. If rebase conflicts → abort, try ``git merge`` instead.
-          3. If merge conflicts → use the AI agent to auto-resolve.
+        """Integrate the current branch with ``origin/{default_branch}``.
+
+        Strategy:
+          - If the current branch already exists on remote (was previously pushed):
+            Skip rebase entirely and use merge only.  Rebase rewrites commit
+            SHAs of already-published commits, which creates divergence and
+            requires a force-push.  Many servers (e.g. Bitbucket Server with
+            branch protection) forbid force-push, so we must preserve the
+            existing remote history by using merge instead.
+          - If the branch is new (first push): try rebase first for a clean
+            linear history; fall back to merge on conflicts.
+          - 3-tier merge fallback: merge → AI-assisted conflict resolution.
         """
         git = self.workspace_manager._git
         target = f"origin/{default_branch}"
@@ -5363,10 +5455,10 @@ class RuntimeDaemon:
         try:
             await git("fetch", "origin", cwd=workspace_path, timeout=300, project_key=project_key)
         except RuntimeError as exc:
-            logger.warning("Pre-push fetch failed: %s — skipping rebase", exc)
+            logger.warning("Pre-push fetch failed: %s — skipping integration", exc)
             return
 
-        # Check if rebase is needed (any commits on origin/default ahead of us?)
+        # Check if integration is needed (any commits on origin/default ahead of us?)
         try:
             behind = await git(
                 "rev-list", "--count", f"HEAD..{target}", cwd=workspace_path,
@@ -5374,27 +5466,56 @@ class RuntimeDaemon:
             if behind.strip() == "0":
                 logger.info("Branch is already up-to-date with %s", target)
                 return
-            logger.info("Branch is %s commit(s) behind %s — rebasing", behind.strip(), target)
+            logger.info("Branch is %s commit(s) behind %s — integrating", behind.strip(), target)
         except RuntimeError:
-            # Can't determine — proceed with rebase anyway
+            # Can't determine — proceed anyway
             pass
 
-        # ── Tier 1: rebase ──
+        # Determine if the current branch already exists on remote.
+        # If it does, a rebase would rewrite the SHAs of already-pushed commits,
+        # causing divergence that requires a force-push (often blocked by server
+        # branch-protection rules).  Use merge-only in that case.
+        current_branch = ""
+        remote_branch_exists = False
         try:
-            await git(
-                "-c", "user.name=Forgexa Agent",
-                "-c", "user.email=agent@forgexa.net",
-                "rebase", target,
-                cwd=workspace_path, timeout=120,
-            )
-            logger.info("Rebase onto %s succeeded", target)
-            return  # done — clean linear history
+            current_branch = (await git(
+                "rev-parse", "--abbrev-ref", "HEAD", cwd=workspace_path,
+            )).strip()
         except RuntimeError:
-            logger.info("Rebase onto %s had conflicts — aborting rebase", target)
+            pass
+        if current_branch and current_branch != "HEAD":
             try:
-                await git("rebase", "--abort", cwd=workspace_path)
+                await git(
+                    "rev-parse", "--verify", f"origin/{current_branch}",
+                    cwd=workspace_path,
+                )
+                remote_branch_exists = True
+            except RuntimeError:
+                remote_branch_exists = False
+
+        if not remote_branch_exists:
+            # ── Tier 1: rebase (safe — branch not yet on remote) ──
+            try:
+                await git(
+                    "-c", "user.name=Forgexa Agent",
+                    "-c", "user.email=agent@forgexa.net",
+                    "rebase", target,
+                    cwd=workspace_path, timeout=120,
+                )
+                logger.info("Rebase onto %s succeeded", target)
+                return  # done — clean linear history
             except RuntimeError:
-                pass  # already aborted or not in rebase state
+                logger.info("Rebase onto %s had conflicts — aborting rebase", target)
+                try:
+                    await git("rebase", "--abort", cwd=workspace_path)
+                except RuntimeError:
+                    pass  # already aborted or not in rebase state
+        else:
+            logger.info(
+                "Branch %s already exists on remote — skipping rebase to preserve "
+                "published commit SHAs (force-push not required)",
+                current_branch,
+            )
 
         # ── Tier 2: merge ──
         try:
@@ -5628,6 +5749,79 @@ class RuntimeDaemon:
                                 return None
                             except RuntimeError as exc:
                                 logger.error("Force-push (with lease) failed for %s: %s", branch, exc)
+                                exc_str = str(exc).lower()
+                                # Detect permanent server-side force-push prohibition
+                                # (e.g. Bitbucket Server branch-protection pre-receive hook).
+                                # In this case we must NOT retry with force — instead, recover
+                                # by resetting to the remote HEAD and cherry-picking only the
+                                # truly new commits, then doing a regular (non-force) push.
+                                force_push_blocked = (
+                                    "force-pushing" in exc_str
+                                    or "force pushing" in exc_str
+                                    or "pre-receive hook declined" in exc_str
+                                )
+                                if force_push_blocked:
+                                    logger.warning(
+                                        "Remote has force-push disabled for branch %s — "
+                                        "attempting cherry-pick recovery to avoid force-push",
+                                        branch,
+                                    )
+                                    try:
+                                        # Identify commits that are genuinely new (not
+                                        # equivalent to any remote commit).  git-cherry
+                                        # lines prefixed with '+' are truly missing from
+                                        # origin; '-' lines are already incorporated (same
+                                        # patch, different SHA — result of prior rebase).
+                                        cherry_out = (await git(
+                                            "cherry", "HEAD", f"origin/{branch}",
+                                            cwd=workspace_path,
+                                        )).strip()
+                                        new_shas = [
+                                            line.split()[1]
+                                            for line in cherry_out.splitlines()
+                                            if line.startswith("+ ")
+                                        ]
+                                        if not new_shas:
+                                            # Nothing genuinely new — remote is already
+                                            # up-to-date, treat as success.
+                                            logger.info(
+                                                "Recovery: no truly new commits on %s — "
+                                                "remote already has equivalent content",
+                                                branch,
+                                            )
+                                            return None
+                                        # Reset local branch to match remote exactly,
+                                        # then replay only the new commits on top.
+                                        await git(
+                                            "reset", "--hard", f"origin/{branch}",
+                                            cwd=workspace_path,
+                                        )
+                                        await git(
+                                            "-c", "user.name=Forgexa Agent",
+                                            "-c", "user.email=agent@forgexa.net",
+                                            "cherry-pick", *new_shas,
+                                            cwd=workspace_path,
+                                        )
+                                        # Now a regular push should succeed.
+                                        await git(
+                                            "push", "-u", "origin", branch,
+                                            cwd=workspace_path, project_key=project_key,
+                                        )
+                                        logger.info(
+                                            "Recovery push succeeded for branch %s "
+                                            "(%d new commit(s) cherry-picked)",
+                                            branch, len(new_shas),
+                                        )
+                                        return None
+                                    except RuntimeError as recovery_exc:
+                                        logger.error(
+                                            "Cherry-pick recovery also failed for %s: %s",
+                                            branch, recovery_exc,
+                                        )
+                                        return (
+                                            f"Push failed: remote has force-push disabled "
+                                            f"and cherry-pick recovery failed: {recovery_exc}"
+                                        )
                                 return f"Push failed: {exc}"
                         else:
                             logger.error(

{forgexa_cli-1.8.3 → forgexa_cli-1.8.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.8.3
+Version: 1.8.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.8.3 → forgexa_cli-1.8.4}/pyproject.toml

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