forgexa-cli 1.18.4__tar.gz → 1.18.6__tar.gz

{forgexa_cli-1.18.4 → forgexa_cli-1.18.6}/PKG-INFO

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

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

{forgexa_cli-1.18.4 → forgexa_cli-1.18.6}/forgexa_cli/daemon.py

@@ -104,6 +104,34 @@ def _save_cli_tokens(access_token: str, refresh_token: str | None = None) -> Non
     token_path.chmod(0o600)
 
 
+def _extract_access_token_subject(token: str | None) -> str | None:
+    raw = str(token or "").strip()
+    if not raw:
+        return None
+
+    parts = raw.split(".")
+    if len(parts) != 3:
+        return None
+
+    payload = parts[1]
+    payload += "=" * (-len(payload) % 4)
+    try:
+        data = json.loads(base64.urlsafe_b64decode(payload.encode("utf-8")))
+    except Exception:
+        return None
+
+    subject = str(data.get("sub") or "").strip()
+    if not subject:
+        return None
+
+    try:
+        UUID(subject)
+    except (TypeError, ValueError):
+        return None
+
+    return subject
+
+
 def _looks_like_pipx_environment(python_path: str | None = None) -> bool:
     candidate = (python_path or sys.executable or "").replace("\\", "/").lower()
     return "/pipx/venvs/" in candidate
@@ -527,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.18.4"
+DAEMON_VERSION = "1.18.6"
 
 
 def _detect_client_type() -> str:
@@ -1313,6 +1341,17 @@ def _get_analysis_outputs_for_type(req_type: str) -> list[str]:
         return _ANALYSIS_OUTPUTS_BY_TYPE.get(req_type, _ANALYSIS_OUTPUTS_BY_TYPE["feature"])
 
 
+def _is_requirement_analysis_path(path: str) -> bool:
+    """Recognize v1 and v2 requirement analysis paths without backend imports."""
+    normalized = str(path or "").replace("\\", "/").lstrip("./")
+    return (
+        normalized.startswith("docs/requirements/")
+        and "/implement/" not in normalized
+        and "/bugfix/" not in normalized
+        and "/delivery/" not in normalized
+    )
+
+
 # Mirrors type_workflow_profiles.py — maps req type to the expected design-phase output filename.
 # Most types use design.md; spike uses research.md (produced by _DESIGN_SPIKE prompt).
 _DESIGN_OUTPUT_BY_TYPE: dict[str, str] = {
@@ -3574,6 +3613,16 @@ class ProcessManager:
         "not found the model",              # decoded Kimi 404 body
         "provider.api_error",               # Kimi SDK error prefix
         "kimi authentication required",     # pre-flight oauth check sentinel
+        # Generic auth/login failures. These are evaluated only against failure
+        # channels, so they are safe to treat as fallback-worthy.
+        "not logged in",
+        "please run /login",
+        "please log in",
+        "authentication failed",
+        "authentication_failed",
+        "authentication required",
+        "authenticate with the github",
+        "gh auth login",
     ]
 
     def __init__(self):
@@ -4015,6 +4064,17 @@ class ProcessManager:
         return normalized
 
     def _required_deliverable_paths(self, task: TaskInfo) -> set[str]:
+        input_data = task.input_data or {}
+        if input_data.get("verification_work_item"):
+            path_by_node_type = {
+                "analysis": input_data.get("verification_analysis_doc_path", ""),
+                "fix": input_data.get("bugfix_doc_path", ""),
+                "testing": input_data.get("verification_test_report_path", ""),
+            }
+            required_path = str(path_by_node_type.get(task.node_type, "") or "")
+            required_path = required_path.replace("\\", "/").lstrip("./")
+            return {required_path} if required_path else set()
+
         # For analysis nodes, deliverables live in analysis_output_dir (docs/requirements/<key>/analysis)
         # For delivery nodes, deliverables live in output_dir (docs/requirements/<key>/delivery)
         # For other nodes, use output_dir (docs/requirements/<key>/implement)
@@ -4354,6 +4414,14 @@ class ProcessManager:
         ]
 
         env = os.environ.copy()
+        for key in (
+            "XDG_CONFIG_HOME",
+            "XDG_DATA_HOME",
+            "XDG_CACHE_HOME",
+            "XDG_STATE_HOME",
+            "CLAUDE_CODE_DEBUG_LOGS_DIR",
+        ):
+            env.pop(key, None)
         model_override = os.environ.get("FACTORY_CLAUDE_MODEL")
         if model_override:
             env["ANTHROPIC_MODEL"] = model_override
@@ -4519,7 +4587,8 @@ class ProcessManager:
         """Run OpenCode CLI in non-interactive mode.
 
         Uses `opencode run --format json --dir <cwd>` for headless execution.
-        The message is passed as a positional argument.
+        The full prompt is attached through a temporary file so it never exceeds
+        the operating system command-line length limit.
         NOTE: `--dir` is the correct flag (not `--cwd` which is invalid).
 
         Each invocation gets an isolated XDG_DATA_HOME so that concurrent
@@ -4566,16 +4635,18 @@ class ProcessManager:
         model_override = os.environ.get("FACTORY_OPENCODE_MODEL")
         if model_override:
             cmd += ["--model", model_override]
-        # -- ensures yargs treats everything after it as positional args, not flags.
-        # Without this, prompts containing --flag-like text cause yargs to print help and exit 1.
-        cmd += ["--", prompt]
-
         # Isolate each opencode run in its own data directory to prevent
         # concurrent processes from racing on the shared SQLite WAL file.
         tmp_data_root = tempfile.mkdtemp(prefix=f"opencode-{task_id[:8]}-")
         try:
             isolated_data_dir = Path(tmp_data_root) / "opencode"
             isolated_data_dir.mkdir()
+            prompt_file = Path(tmp_data_root) / "instructions.md"
+            prompt_file.write_text(prompt, encoding="utf-8")
+            cmd += [
+                "--file", str(prompt_file),
+                "--", "Read and follow the attached instructions.",
+            ]
             # Copy auth.json so provider credentials are available.
             auth_src = Path.home() / ".local" / "share" / "opencode" / "auth.json"
             if auth_src.exists():
@@ -4760,49 +4831,45 @@ class ProcessManager:
     def _prepare_claude_environment(
         sandbox_root: "Path | None" = None,
     ) -> dict[str, str]:
-        """Prepare writable Claude config/data/cache dirs for isolated execution.
+        """Prepare an isolated Claude home and mirror stable configuration files.
 
         When *sandbox_root* is given (per-task isolation via mkdtemp), uses that
         directory.  When None, falls back to the shared legacy path under ~/.forgexa.
 
         The daemon service runs with ProtectSystem=strict and only allows
-        writes under ~/.forgexa plus the workspace root. Claude Code writes
-        config, debug logs, cache, and session state under XDG paths and
-        ~/.claude by default, and newer builds may still touch $HOME/.claude.json
-        even when XDG paths are set. That can fail with EROFS inside the daemon.
-
-        Point Claude at writable daemon-owned directories, redirect HOME to
-        the same writable sandbox, and mirror only the small set of user
-        config files it needs for headless execution.
+        writes under ~/.forgexa plus the workspace root. Redirecting HOME lets
+        Claude use its default config, cache, and session locations under a
+        writable task sandbox.
+
+        Mirror only stable authentication and settings files. 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
+        a file after TodoWrite and exits with EISDIR.
         """
         if sandbox_root is None:
             sandbox_root = Path.home() / ".forgexa" / "claude-home"
-        config_root = sandbox_root / "config"
-        data_root = sandbox_root / "data"
-        cache_root = sandbox_root / "cache"
-        state_root = sandbox_root / "state"
         home_claude_dir = sandbox_root / ".claude"
-        claude_config_dir = config_root / "claude"
 
         for path in (
-            config_root,
-            data_root,
-            cache_root,
-            state_root,
             home_claude_dir,
-            claude_config_dir,
         ):
             path.mkdir(parents=True, exist_ok=True)
 
         source_files = [
             (Path.home() / ".claude.json", sandbox_root / ".claude.json"),
-            (Path.home() / ".claude.json", claude_config_dir / ".claude.json"),
             (Path.home() / ".claude" / "settings.json", home_claude_dir / "settings.json"),
-            (Path.home() / ".claude" / "settings.json", claude_config_dir / "settings.json"),
+            (Path.home() / ".claude" / "settings.local.json", home_claude_dir / "settings.local.json"),
         ]
         for source, dest in source_files:
             try:
-                if source.is_file() and not dest.exists():
+                if not source.is_file():
+                    continue
+                if dest.is_dir():
+                    shutil.rmtree(dest)
+                elif dest.is_file() or dest.is_symlink():
+                    dest.unlink()
+                if not dest.exists():
                     shutil.copy2(source, dest)
             except Exception as exc:
                 logger.debug(
@@ -4812,19 +4879,11 @@ class ProcessManager:
 
         env = {
             "HOME": str(sandbox_root),
-            "XDG_CONFIG_HOME": str(config_root),
-            "XDG_DATA_HOME": str(data_root),
-            "XDG_CACHE_HOME": str(cache_root),
-            "XDG_STATE_HOME": str(state_root),
             "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": str(
                 os.environ.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "1")
             ),
         }
 
-        if not os.environ.get("CLAUDE_CODE_DEBUG_LOGS_DIR"):
-            env["CLAUDE_CODE_DEBUG_LOGS_DIR"] = str(cache_root / "claude-debug")
-            Path(env["CLAUDE_CODE_DEBUG_LOGS_DIR"]).mkdir(parents=True, exist_ok=True)
-
         return env
 
     @staticmethod
@@ -6228,6 +6287,7 @@ class TaskPoller:
         self._on_success = lambda: None  # Callbacks set by ServerConnection
         self._on_auth_failure = lambda: None
         self._empty_cycles = 0
+        self.cancelled_ai_job_ids: list[str] = []
 
     def note_activity(self, *, had_work: bool) -> None:
         if had_work:
@@ -6288,12 +6348,20 @@ class TaskPoller:
             )
             if resp.status_code == 200:
                 self._on_success()
-                return resp.json().get("ai_jobs", [])
+                data = resp.json()
+                self.cancelled_ai_job_ids = [
+                    str(job_id)
+                    for job_id in data.get("cancelled_job_ids", [])
+                    if job_id
+                ]
+                return data.get("ai_jobs", [])
             elif resp.status_code in (401, 403):
                 self._on_auth_failure()
+            self.cancelled_ai_job_ids = []
             return []
         except Exception as e:
             logger.debug("AIJob poll error: %s", e)
+            self.cancelled_ai_job_ids = []
             return []
 
 
@@ -6720,17 +6788,36 @@ class RuntimeDaemon:
             except Exception:
                 from jose import jwt as jwt_module
 
+            token_path = Path.home() / ".forgexa" / "token"
+            preferred_user_id = None
+            try:
+                if token_path.exists():
+                    preferred_user_id = _extract_access_token_subject(token_path.read_text().strip())
+            except OSError:
+                preferred_user_id = None
+
             async with engine.connect() as conn:
-                row = await conn.execute(
-                    select(User.id)
-                    .order_by(
-                        case((User.status == "active", 0), else_=1),
-                        User.created_at,
+                uid = None
+                if preferred_user_id:
+                    preferred_result = await conn.execute(
+                        select(User.id)
+                        .where(User.id == UUID(preferred_user_id))
+                        .limit(1)
                     )
-                    .limit(1)
-                )
-                r = row.first()
-                uid = str(r[0]) if r else None
+                    preferred_row = preferred_result.first()
+                    uid = str(preferred_row[0]) if preferred_row else None
+
+                if not uid:
+                    row = await conn.execute(
+                        select(User.id)
+                        .order_by(
+                            case((User.status == "active", 0), else_=1),
+                            User.created_at,
+                        )
+                        .limit(1)
+                    )
+                    r = row.first()
+                    uid = str(r[0]) if r else None
 
             if uid:
                 token = jwt_module.encode(
@@ -7051,6 +7138,19 @@ class RuntimeDaemon:
     async def _poll_and_execute(self) -> bool:
         """Poll for tasks from all connected servers and execute them."""
         had_work = False
+
+        def _cancel_server_requested_ai_jobs(conn: ServerConnection) -> None:
+            for job_id in conn.poller.cancelled_ai_job_ids:
+                ai_task_key = f"aijob_{job_id}"
+                active_task = self.active_tasks.get(ai_task_key)
+                if not active_task or active_task.done():
+                    continue
+                active_process = self.process_manager.active_processes.get(job_id)
+                if active_process:
+                    _kill_proc(active_process)
+                active_task.cancel()
+                logger.info("[%s] Cancelled AIJob %s at server request", conn.label, job_id)
+
         # Clean up completed tasks
         for task_id in list(self.active_tasks):
             if self.active_tasks[task_id].done():
@@ -7063,24 +7163,21 @@ class RuntimeDaemon:
             if conn.heartbeat:
                 conn.heartbeat.update(total_active, self._agents_as_dicts())
 
-        # Check capacity
-        if total_active >= self.max_concurrent:
-            return True
-
         # Poll from all connected servers
         for conn in self.connections:
-            if total_active >= self.max_concurrent:
-                break
-
-            tasks = await conn.poller.poll()
-            ai_jobs: list[dict] = []
-            if len(self.active_tasks) < self.max_concurrent:
-                ai_jobs = await conn.poller.poll_ai_jobs()
+            has_capacity = total_active < self.max_concurrent
+            tasks = await conn.poller.poll() if has_capacity else []
+            # Always poll AI jobs so server-requested cancellations can stop a
+            # process that is itself consuming the last available slot.
+            ai_jobs = await conn.poller.poll_ai_jobs()
+            _cancel_server_requested_ai_jobs(conn)
+            total_active = len(self.active_tasks)
+            has_capacity = total_active < self.max_concurrent
 
             conn.poller.note_activity(had_work=bool(tasks or ai_jobs))
             had_work = had_work or bool(tasks or ai_jobs)
 
-            for task in tasks:
+            for task in tasks if has_capacity else []:
                 if task.task_id in self.active_tasks:
                     continue  # Already running
 
@@ -7096,7 +7193,7 @@ class RuntimeDaemon:
                 )
 
             # Poll for AIJobs (workspace-mode tasks)
-            for aj in ai_jobs:
+            for aj in ai_jobs if has_capacity else []:
                 job_id = aj.get("job_id", "")
                 ai_task_key = f"aijob_{job_id}"
                 if ai_task_key in self.active_tasks:
@@ -7110,6 +7207,9 @@ class RuntimeDaemon:
                     self._execute_ai_job(aj, conn)
                 )
 
+                total_active = len(self.active_tasks)
+                has_capacity = total_active < self.max_concurrent
+
         return had_work
 
     async def _workspace_checkout_health_error(self, workspace_path: Path) -> str | None:
@@ -7744,7 +7844,11 @@ class RuntimeDaemon:
 
             # 4.55 Analysis/design/fix nodes must update their deliverables in THIS run.
             # Existing files from a prior iteration are not sufficient evidence.
-            if result.status == "success" and task.node_type in ("analysis", "design", "fix"):
+            requires_current_run_deliverable = task.node_type in ("analysis", "design", "fix") or (
+                task.node_type == "testing"
+                and bool((task.input_data or {}).get("verification_work_item"))
+            )
+            if result.status == "success" and requires_current_run_deliverable:
                 committed_git = await self.process_manager._collect_git_info_vs_parent(
                     workspace_path,
                     default_branch=default_branch,
@@ -7807,7 +7911,11 @@ class RuntimeDaemon:
             # This closes the mirror-sync gap: review agents update analysis.json
             # (open_risks, phase_handoffs) and this step ensures the content reaches
             # runtimes.py as an inline artifact regardless of push success.
-            if result.status == "success" and task.node_type in ("review", "coding", "testing"):
+            if (
+                result.status == "success"
+                and task.node_type in ("review", "coding", "testing")
+                and not bool((task.input_data or {}).get("verification_work_item"))
+            ):
                 analysis_dir = (
                     (task.input_data or {}).get("analysis_output_dir", "")
                     or ""
@@ -8011,7 +8119,40 @@ class RuntimeDaemon:
 
         issues: list[str] = []
         node_type = task.node_type
-        req_type = (task.input_data or {}).get("requirement_type", "feature")
+        input_data = task.input_data or {}
+        req_type = input_data.get("requirement_type", "feature")
+        verification_work_item = bool(input_data.get("verification_work_item"))
+
+        if verification_work_item:
+            forbidden_paths = sorted(
+                path
+                for path in ProcessManager._normalize_repo_paths(result.files_changed)
+                if _is_requirement_analysis_path(path)
+            )
+            if forbidden_paths:
+                issues.append(
+                    "Verification work item modified requirement analysis assets: "
+                    + ", ".join(forbidden_paths[:5])
+                )
+
+        if verification_work_item and node_type == "analysis":
+            analysis_doc_path = str(input_data.get("verification_analysis_doc_path", "") or "")
+            analysis_doc_path = analysis_doc_path.replace("\\", "/").lstrip("./")
+            analysis_doc = workspace_path / analysis_doc_path
+            if not analysis_doc_path or not analysis_doc.exists():
+                issues.append(f"Verification analysis record missing: {analysis_doc_path}")
+            elif analysis_doc.stat().st_size == 0:
+                issues.append(f"Verification analysis record is empty: {analysis_doc_path}")
+            return issues
+
+        if verification_work_item and node_type == "testing":
+            test_report_path = str(input_data.get("verification_test_report_path", "") or "")
+            test_report_path = test_report_path.replace("\\", "/").lstrip("./")
+            test_report = workspace_path / test_report_path
+            if not test_report_path or not test_report.exists():
+                issues.append(f"Verification test report missing: {test_report_path}")
+            elif test_report.stat().st_size == 0:
+                issues.append(f"Verification test report is empty: {test_report_path}")
 
         if node_type == "analysis":
             # Use type profile to determine required analysis outputs
@@ -8182,7 +8323,7 @@ class RuntimeDaemon:
                         pass  # analysis.json corrupt — already flagged elsewhere
 
             # Testing-specific: validate structured test assets
-            if node_type == "testing":
+            if node_type == "testing" and not verification_work_item:
                 # Determine which checks to run for this requirement type.
                 #
                 # _skip_test_artifacts = True  → skip ALL artifact checks
@@ -8777,21 +8918,26 @@ class RuntimeDaemon:
         always receives the file contents via the completion report and gate
         reviewers can see the analysis documents immediately.
         """
-        # Analysis deliverables live in analysis_output_dir (docs/requirements/...)
-        doc_dir = (
-            (task.input_data or {}).get("analysis_output_dir", "")
-            or (task.input_data or {}).get("output_dir", "")
-        )
-        if not doc_dir:
-            return
+        input_data = task.input_data or {}
+        verification_work_item = bool(input_data.get("verification_work_item"))
+        if verification_work_item:
+            analysis_doc_path = str(input_data.get("verification_analysis_doc_path", "") or "")
+            candidate_paths = [analysis_doc_path] if analysis_doc_path else []
+        else:
+            # Analysis deliverables live in analysis_output_dir (docs/requirements/...)
+            doc_dir = input_data.get("analysis_output_dir", "") or input_data.get("output_dir", "")
+            if not doc_dir:
+                return
+            base = workspace_path / doc_dir.lstrip("./")
+            req_type = input_data.get("requirement_type", "feature")
+            candidate_paths = [str(base / fname) for fname in _get_analysis_outputs_for_type(req_type)]
 
-        base = workspace_path / doc_dir.lstrip("./")
-        req_type = (task.input_data or {}).get("requirement_type", "feature")
-        _ANALYSIS_FILES = _get_analysis_outputs_for_type(req_type)
         existing_artifact_paths = {a.get("path", "").replace("\\", "/") for a in result.artifacts}
 
-        for fname in _ANALYSIS_FILES:
-            fpath = base / fname
+        for candidate_path in candidate_paths:
+            fpath = Path(candidate_path)
+            if not fpath.is_absolute():
+                fpath = workspace_path / fpath
             if not fpath.exists() or fpath.stat().st_size == 0:
                 continue
             try:
@@ -8799,7 +8945,7 @@ class RuntimeDaemon:
                 if rel_path in existing_artifact_paths:
                     continue  # already attached
                 content = fpath.read_text(encoding="utf-8", errors="replace")
-                mime = "text/markdown" if fname.endswith(".md") else "application/json"
+                mime = "text/markdown" if rel_path.endswith(".md") else "application/json"
                 result.artifacts.append({
                     "path": rel_path,
                     "content": content,
@@ -8809,7 +8955,7 @@ class RuntimeDaemon:
                     "Attached analysis artifact inline: %s (%d bytes)", rel_path, len(content)
                 )
             except Exception as e:
-                logger.warning("Failed to read analysis artifact %s: %s", fname, e)
+                logger.warning("Failed to read analysis artifact %s: %s", candidate_path, e)
 
     async def _collect_design_artifacts(
         self, workspace_path: Path, task: TaskInfo, result: TaskResult

{forgexa_cli-1.18.4 → forgexa_cli-1.18.6}/forgexa_cli.egg-info/PKG-INFO

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

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