forgexa-cli 1.14.7__tar.gz → 1.14.9__tar.gz

{forgexa_cli-1.14.7 → forgexa_cli-1.14.9}/PKG-INFO

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

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

{forgexa_cli-1.14.7 → forgexa_cli-1.14.9}/forgexa_cli/daemon.py

@@ -523,7 +523,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.14.7"
+DAEMON_VERSION = "1.14.9"
 
 
 def _detect_client_type() -> str:
@@ -1711,17 +1711,27 @@ class WorkspaceManager:
 
     @staticmethod
     def _safe_rmtree(path: Path) -> None:
-        """Remove a directory tree, handling read-only files on Windows.
-
-        On Windows, git object files (.git/objects/**/*) are stored read-only
-        (mode 0444).  Plain shutil.rmtree(path, ignore_errors=True) silently
-        skips those files, leaving the directory intact.  A subsequent
-        git clone then fails with 'destination path already exists and is
-        not an empty directory'.
-
-        This method uses the onerror callback to chmod each entry writable
-        before retrying — the established pattern for handling git repos on
-        Windows.
+        """Remove a directory tree, handling two distinct Windows failure modes.
+
+        Mode 1 — Read-only git objects (chmod 0444):
+          Plain shutil.rmtree(path, ignore_errors=True) silently skips
+          read-only files.  Fixed by the onerror callback that chmod’s each
+          entry writable before retrying.
+
+        Mode 2 — Windows reserved device names (NUL, CON, AUX, PRN,
+          COM1–COM9, LPT1–LPT9):
+          The Win32 API intercepts these names before they reach the NTFS
+          driver, so os.unlink / shutil.rmtree / PowerShell Remove-Item all
+          fail with a permissions or access error.  The solution is the
+          \\?\ extended-length path prefix, which instructs Windows to
+          skip Win32 name parsing and pass the path directly to the NT
+          kernel file-system layer.  'cmd /c rmdir /s /q' reliably handles
+          this when given a \\?\ prefixed path.
+
+        Deletion strategy (each stage only runs if the path still exists):
+          1. shutil.rmtree with onerror chmod  — handles read-only objects.
+          2. Windows only: subprocess cmd /c rmdir /s /q \\\\?\\<path>  —
+             handles reserved names and any entries missed by stage 1.
         """
         import shutil
         import stat as _stat
@@ -1738,6 +1748,39 @@ class WorkspaceManager:
 
         shutil.rmtree(path, onerror=_handle_readonly)
 
+        # Windows fallback: reserved device names survive shutil.rmtree.
+        # cmd /c rmdir /s /q with the \\?\ extended-length prefix bypasses
+        # Win32 name interception and reaches the NTFS layer directly.
+        if path.exists() and sys.platform == "win32":
+            try:
+                import subprocess
+                resolved = str(path.resolve())
+                # Prepend \\?\ extended-length prefix if not already present.
+                # In Python source "\\\\?\\" represents the 4-char string \\?\
+                # which is the Win32 flag to bypass reserved-name interception.
+                if not resolved.startswith("\\\\?\\"):
+                    unc = "\\\\?\\" + resolved
+                else:
+                    unc = resolved
+                result = subprocess.run(
+                    ["cmd", "/c", "rmdir", "/s", "/q", unc],
+                    capture_output=True,
+                    timeout=60,
+                )
+                if result.returncode != 0 and path.exists():
+                    logger.warning(
+                        "_safe_rmtree: cmd rmdir could not fully remove %s "
+                        "(exit %d: %s). Manual deletion may be required.",
+                        path,
+                        result.returncode,
+                        result.stderr.decode(errors="replace").strip()[:200],
+                    )
+            except Exception as exc:
+                logger.warning(
+                    "_safe_rmtree: Windows rmdir fallback failed for %s: %s",
+                    path, exc,
+                )
+
     async def _clone_repo(
         self,
         repo_url: str,
@@ -1849,8 +1892,16 @@ class WorkspaceManager:
             # the initial analysis.  This ensures a hard error (and workspace
             # re-clone) when the branch sync fails, rather than silently proceeding
             # with a stale workspace that will cause a non-fast-forward push later.
-            expect_branch = bool(task.analysis_branch) or (
-                bool(task.requirement_key) and not is_fresh_start and task.node_type != "analysis"
+            #
+            # IMPORTANT: Fresh analysis tasks MUST NOT set expect_branch even when
+            # task.analysis_branch is populated from workflow metadata.  That value
+            # reflects the branch from a *previous* analysis run (e.g. a prior Copilot
+            # analysis) which may have been deleted as part of the fresh restart.
+            # Only refine/continuation tasks require the branch to already exist.
+            expect_branch = (not is_fresh_start) and (
+                bool(task.analysis_branch) or (
+                    bool(task.requirement_key) and task.node_type != "analysis"
+                )
             )
             ws_path = await self._create_worktree(
                 project_dir, repo_url, default_branch, workspace_key, branch_name,
@@ -2351,16 +2402,41 @@ class WorkspaceManager:
                     _branch_fetch_ok = False
 
                 if fresh_start and not _branch_fetch_ok:
-                    # Cannot determine remote branch state — prohibit reset to avoid
-                    # silently destroying implementation commits that exist on the remote
-                    # but could not be fetched (auth/network failure).  Conservative
-                    # stance: treat unverified state as "has implementation work".
-                    logger.warning(
-                        "Fresh start blocked for %s: branch fetch failed (%s) — "
-                        "remote state unknown, refusing to reset to avoid data loss",
-                        branch_name, _last_sync_err[:200],
+                    # Distinguish "branch not found" from "auth/network failure".
+                    # When the branch simply doesn't exist on the remote, that is the
+                    # *expected* state for a fresh analysis restart (the branch was
+                    # deleted by a prior fresh run or was never pushed).  In that case
+                    # keep fresh_start=True so the worktree is correctly reset to the
+                    # default branch.
+                    # Only block fresh_start when the fetch failed for reasons other
+                    # than "not found" (e.g. auth/SSH/network issues) where we genuinely
+                    # cannot determine whether implementation commits exist on the remote.
+                    _err_lower = _last_sync_err.lower()
+                    _branch_not_found = (
+                        "couldn't find remote ref" in _err_lower
+                        or "无法找到远程引用" in _err_lower   # Chinese git output
+                        or "remote ref does not exist" in _err_lower
+                        or "not found" in _err_lower
                     )
-                    fresh_start = False
+                    if _branch_not_found:
+                        # Branch is gone from remote — ideal state for a fresh restart.
+                        logger.info(
+                            "Fresh start for %s: remote branch not found — expected for a "
+                            "fresh analysis restart (branch was deleted or never existed). "
+                            "Proceeding with clean worktree reset to origin/%s",
+                            branch_name, default_branch,
+                        )
+                        # fresh_start remains True
+                    else:
+                        # Cannot determine remote branch state (auth/network failure) —
+                        # prohibit reset to avoid silently destroying implementation commits
+                        # that may exist on the remote but could not be fetched.
+                        logger.warning(
+                            "Fresh start blocked for %s: branch fetch failed (%s) — "
+                            "remote state unknown, refusing to reset to avoid data loss",
+                            branch_name, _last_sync_err[:200],
+                        )
+                        fresh_start = False
 
                 if fresh_start:
                     # Safety check: if the branch already has IMPLEMENTATION commits
@@ -4490,6 +4566,17 @@ class ProcessManager:
 
         Mirror the user-facing ~/.copilot state into a writable daemon-owned
         directory, then point COPILOT_HOME there for non-interactive runs.
+
+        Stale-auth cleanup: Before the per-task isolation fix, the daemon
+        pointed COPILOT_HOME directly at this master directory, so Copilot
+        wrote its own OAuth token (plain-text on Linux systems without a
+        credential store) here. Those files are NOT present in ~/.copilot/
+        (the user's interactive home), so the normal mirror loop never
+        overwrites them — they persist across restarts and poison isolated
+        temp dirs.  We clean up any file/dir in the master home that has no
+        counterpart in ~/.copilot/ (excluding session-state and logs which
+        are deliberately retained) to ensure the master home stays a clean
+        mirror of the user-facing directory.
         """
         source_root = Path.home() / ".copilot"
         target_root = Path.home() / ".forgexa" / "copilot-home"
@@ -4498,6 +4585,26 @@ class ProcessManager:
         if not source_root.exists():
             return str(target_root)
 
+        # Collect names present in source for stale-file detection.
+        source_names: set[str] = {child.name for child in source_root.iterdir()}
+
+        # Remove master-home entries that are absent from ~/.copilot/.
+        # These are typically old Copilot OAuth token files written when
+        # COPILOT_HOME pointed here directly (pre-isolation-fix era).
+        _keep_always = {"session-state", "logs"}
+        for target_child in list(target_root.iterdir()):
+            if target_child.name in _keep_always:
+                continue
+            if target_child.name not in source_names:
+                try:
+                    if target_child.is_dir():
+                        shutil.rmtree(str(target_child), ignore_errors=True)
+                    else:
+                        target_child.unlink(missing_ok=True)
+                    logger.debug("Copilot home: removed stale %s", target_child.name)
+                except Exception as exc:
+                    logger.debug("Copilot home: could not remove stale %s: %s", target_child.name, exc)
+
         for child in source_root.iterdir():
             if child.name in {"logs", "session-state"}:
                 continue
@@ -4585,6 +4692,37 @@ class ProcessManager:
         env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
         env["COPILOT_HOME"] = _isolated_copilot_home
 
+        # Inject GH_TOKEN from the gh CLI for headless/automation auth.
+        # Per `copilot login --help`, env-var auth is the recommended method
+        # for automation: COPILOT_GITHUB_TOKEN > GH_TOKEN > GITHUB_TOKEN.
+        # GH_TOKEN accepts OAuth tokens from the GitHub CLI (gh) app, which
+        # is exactly what `gh auth token` returns.
+        #
+        # This bypasses any stale Copilot-specific OAuth token file that may
+        # be cached in COPILOT_HOME from an earlier run (e.g., after a
+        # password change when `gh auth login` refreshes gh's token but does
+        # NOT update Copilot's own stored token).  After `gh auth login` the
+        # daemon works again without requiring `copilot login` or manual
+        # deletion of ~/.forgexa/copilot-home/.
+        if not any(env.get(k) for k in ("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN")):
+            try:
+                _gh_proc = await asyncio.create_subprocess_exec(
+                    "gh", "auth", "token",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.DEVNULL,
+                    stdin=asyncio.subprocess.DEVNULL,
+                )
+                _gh_token_out, _ = await asyncio.wait_for(_gh_proc.communicate(), timeout=10.0)
+                _gh_token = (_gh_token_out or b"").decode().strip()
+                if _gh_token:
+                    env["GH_TOKEN"] = _gh_token
+                    logger.debug("Copilot task %s: injected GH_TOKEN from gh CLI", task_id)
+            except Exception as _gh_exc:
+                logger.debug(
+                    "Copilot task %s: could not inject GH_TOKEN (%s); falling back to stored auth",
+                    task_id, _gh_exc,
+                )
+
         model_override = os.environ.get("FACTORY_COPILOT_MODEL")
         # FACTORY_COPILOT_REASONING is opt-in: only pass --effort when the env
         # var is explicitly set to a non-empty string.  The default (unset / "")
@@ -4616,6 +4754,18 @@ class ProcessManager:
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
+                # stdin=DEVNULL is critical on Windows.
+                # Without it, the child process inherits the parent daemon's stdin.
+                # On Windows, the daemon often has a real console handle on stdin
+                # (e.g. from a CMD/PowerShell window or the Desktop app's console).
+                # Copilot CLI detects this via GetConsoleMode(GetStdHandle(STD_INPUT))
+                # and enters interactive/session-check mode, ignoring -p as a task:
+                # it checks the session todo table (empty), reports "no tracked work
+                # items", and waits for user input instead of executing the task.
+                # On Linux/macOS (daemon as service), stdin is typically /dev/null so
+                # the bug doesn't manifest.  Explicit DEVNULL ensures non-interactive
+                # mode on all platforms, matching the intended headless operation.
+                stdin=asyncio.subprocess.DEVNULL,
                 cwd=str(cwd),
                 env=env,
                 limit=100 * 1024 * 1024,
@@ -4713,12 +4863,27 @@ class ProcessManager:
                 if effective_rc == 1 and _no_tools and not copilot_specific_error:
                     logger.error(
                         "Copilot exitCode=1 with no tool calls for task %s after retries. "
-                        "Likely causes: (1) GitHub auth expired — run `gh auth status` and "
-                        "`gh auth login --scopes copilot`; (2) Copilot subscription inactive; "
+                        "Likely causes: (1) GitHub auth expired — run `gh auth status`; if "
+                        "expired, run `copilot login` (Copilot's own auth) and `gh auth login`; "
+                        "(2) Copilot subscription inactive; "
                         "(3) --allow-all flag not supported by this CLI version (%s). "
                         "To reproduce manually: %s",
                         task_id, agent.version, _cmd_display,
                     )
+                # Detect auth-specific error for targeted diagnostics.
+                _is_auth_error = any(
+                    "gh auth login" in str(msg) or "authenticate with the GitHub" in str(msg)
+                    for msg in structured_errors
+                )
+                if _is_auth_error:
+                    logger.error(
+                        "Copilot auth error for task %s: %s. "
+                        "Fix: (1) run 'gh auth login' to refresh gh credentials; "
+                        "(2) run 'copilot login' to refresh Copilot's own OAuth token; "
+                        "(3) if the issue persists, delete ~/.forgexa/copilot-home/ and retry.",
+                        task_id,
+                        structured_errors[-1] if structured_errors else "auth failure",
+                    )
                 if copilot_specific_error:
                     failure_error = copilot_specific_error[:1500]
                 elif stderr.strip():

{forgexa_cli-1.14.7 → forgexa_cli-1.14.9}/forgexa_cli.egg-info/PKG-INFO

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

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