forgexa-cli 1.6.1__tar.gz → 1.7.2__tar.gz

{forgexa_cli-1.6.1 → forgexa_cli-1.7.2}/PKG-INFO

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

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

{forgexa_cli-1.6.1 → forgexa_cli-1.7.2}/forgexa_cli/daemon.py

@@ -10,6 +10,20 @@ Usage:
 
 from __future__ import annotations
 
+import sys
+
+# ── Python version gate — must run before any other imports ──────────────────
+# Emit a machine-readable DAEMON_ERROR so the desktop app shows a clear
+# message instead of a cryptic traceback.
+if sys.version_info < (3, 9):
+    _ver = f"{sys.version_info.major}.{sys.version_info.minor}"
+    print(
+        f"DAEMON_ERROR: Python {_ver} is too old. Forgexa Daemon requires Python 3.9 or "
+        f"newer. Please upgrade Python from https://www.python.org/downloads/",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
 import asyncio
 import base64
 import hashlib
@@ -307,7 +321,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.6.1"
+DAEMON_VERSION = "1.7.2"
 
 
 def _detect_client_type() -> str:
@@ -2834,6 +2848,23 @@ class TaskPoller:
             logger.warning("Task poll error: %s", e)
             return []
 
+    async def poll_ai_jobs(self) -> list[dict]:
+        """Poll for AIJobs dispatched to this daemon (workspace-mode)."""
+        try:
+            resp = await self.client.get(
+                f"{self.server_url}/api/v1/runtimes/{self.runtime_id}/ai-jobs/poll",
+                timeout=10,
+            )
+            if resp.status_code == 200:
+                self._on_success()
+                return resp.json().get("ai_jobs", [])
+            elif resp.status_code in (401, 403):
+                self._on_auth_failure()
+            return []
+        except Exception as e:
+            logger.debug("AIJob poll error: %s", e)
+            return []
+
 
 # ── Server Connection ──
 
@@ -3214,6 +3245,11 @@ class RuntimeDaemon:
 
                 if not acquired:
                     logger.error("Cannot acquire daemon lock — another instance may still be running")
+                    print(
+                        "DAEMON_ERROR: Cannot acquire daemon lock — another daemon instance may "
+                        "still be running. Stop the existing daemon first or restart the machine.",
+                        file=sys.stderr,
+                    )
                     raise SystemExit(1)
 
             # Write PID to lock file (for reference, though unreadable while locked)
@@ -3269,6 +3305,11 @@ class RuntimeDaemon:
                 fcntl.flock(self._lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
             except (IOError, OSError):
                 logger.error("Cannot acquire daemon lock — another instance may still be running")
+                print(
+                    "DAEMON_ERROR: Cannot acquire daemon lock — another daemon instance may "
+                    "still be running. Stop the existing daemon first or restart the machine.",
+                    file=sys.stderr,
+                )
                 raise SystemExit(1)
 
         # Write our PID to the lock file for reference
@@ -3411,6 +3452,23 @@ class RuntimeDaemon:
                     self._execute_task(task, conn)
                 )
 
+            # Poll for AIJobs (workspace-mode tasks)
+            if len(self.active_tasks) < self.max_concurrent:
+                ai_jobs = await conn.poller.poll_ai_jobs()
+                for aj in ai_jobs:
+                    job_id = aj.get("job_id", "")
+                    ai_task_key = f"aijob_{job_id}"
+                    if ai_task_key in self.active_tasks:
+                        continue
+                    if len(self.active_tasks) >= self.max_concurrent:
+                        break
+                    logger.info("[%s] Starting AIJob %s (type=%s)",
+                               conn.label, job_id, aj.get("task_type"))
+                    self._task_connections[ai_task_key] = conn
+                    self.active_tasks[ai_task_key] = asyncio.create_task(
+                        self._execute_ai_job(aj, conn)
+                    )
+
     async def _execute_task(self, task: TaskInfo, conn: ServerConnection):
         """Execute a single task, reporting to the originating server connection."""
         reporter = conn.reporter
@@ -3975,6 +4033,139 @@ class RuntimeDaemon:
 
         return issues
 
+    async def _execute_ai_job(self, aj: dict, conn: "ServerConnection"):
+        """Execute an AIJob in daemon workspace and report results back.
+
+        Uses WorkspaceManager for branch-based isolation, runs the agent CLI
+        with the job's prompt, auto-commits results, and reports back.
+        """
+        job_id = aj.get("job_id", "")
+        task_type = aj.get("task_type", "unknown")
+        project_info = aj.get("project", {})
+        requirement_key = aj.get("requirement_key")
+        agent_override = aj.get("agent_override")
+        system_prompt = aj.get("system_prompt", "")
+        user_prompt = aj.get("user_prompt", "")
+
+        reporter_url = f"{conn.server_url.rstrip('/')}/api/v1/runtimes/{conn.runtime_id}/ai-jobs/{job_id}"
+
+        try:
+            # Report progress: starting
+            await conn.client.post(
+                f"{reporter_url}/progress",
+                json={"current_phase": "preparing", "current_step": "Preparing workspace...", "progress_pct": 5},
+                timeout=10,
+            )
+
+            # 1. Select agent
+            agent_type = agent_override or "claude-code"
+            agent = self._select_agent(agent_type, [])
+            if not agent:
+                await conn.client.post(
+                    f"{reporter_url}/complete",
+                    json={"status": "failed", "error": f"No agent CLI for '{agent_type}'", "failure_code": "no_agent"},
+                    timeout=10,
+                )
+                return
+
+            # 2. Prepare workspace (using project info + requirement branch)
+            full_prompt = f"{system_prompt}\n\n{user_prompt}" if system_prompt else user_prompt
+            fake_task = TaskInfo(
+                task_id=job_id,
+                graph_id="",
+                node_type="ai_job",
+                agent_type=agent_type,
+                input_prompt=full_prompt,
+                input_data={},
+                timeout_seconds=settings.AGENT_TIMEOUT,
+                max_retries=0,
+                retry_count=0,
+                project=project_info,
+                work_item={},
+                fallback_chain=[],
+                requirement_workflow_id=None,
+                requirement_key=requirement_key,
+                graph_type="ai_job",
+            )
+            workspace_path = await self.workspace_manager.prepare_workspace(
+                project_info, fake_task,
+            )
+
+            await conn.client.post(
+                f"{reporter_url}/progress",
+                json={"current_phase": "running", "current_step": "Running agent...", "progress_pct": 15},
+                timeout=10,
+            )
+
+            # 3. Run agent with prompt
+            _line_buffer: list[str] = []
+
+            async def on_chunk(lines: list[str]):
+                _line_buffer.extend(lines)
+
+            result = await self.process_manager.run_agent(
+                agent, fake_task, workspace_path, on_chunk=on_chunk,
+            )
+
+            # 4. Auto-commit if successful
+            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 ""
+            scripts: dict = {}
+
+            # Try to extract per-scenario scripts from output
+            scenario_ids = aj.get("input_context", {}).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
+                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
+
+            complete_payload = {
+                "status": "success" if result.status == "success" else "failed",
+                "output_content": output_content,
+                "output_result": {
+                    "scripts": scripts,
+                    "files_changed": result.files_changed,
+                    "lines_added": result.lines_added,
+                    "lines_removed": result.lines_removed,
+                },
+                "tier_used": "agent_cli",
+                "resolved_agent": agent.agent_id,
+                "git_info": git_info,
+                "error": result.error if result.status != "success" else "",
+                "failure_code": "agent_error" if result.status != "success" else "",
+            }
+
+            await conn.client.post(
+                f"{reporter_url}/complete",
+                json=complete_payload,
+                timeout=30,
+            )
+            logger.info("AIJob %s completed: %s", job_id, result.status)
+
+        except Exception as e:
+            logger.exception("AIJob %s execution error", job_id)
+            try:
+                await conn.client.post(
+                    f"{reporter_url}/complete",
+                    json={"status": "failed", "error": str(e)[:2000], "failure_code": "daemon_exception"},
+                    timeout=10,
+                )
+            except Exception:
+                pass
+
     async def _validate_and_retry(
         self,
         agent: "DiscoveredAgent",

{forgexa_cli-1.6.1 → forgexa_cli-1.7.2}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.6.1
+Version: 1.7.2
 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.6.1 → forgexa_cli-1.7.2}/pyproject.toml

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