forgexa-cli 1.14.6__tar.gz → 1.14.8__tar.gz

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.6
+Version: 1.14.8
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT
@@ -26,8 +26,10 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.24
+Requires-Dist: socksio>=1.0.0
 Provides-Extra: daemon
 Requires-Dist: httpx>=0.24; extra == "daemon"
+Requires-Dist: socksio>=1.0.0; extra == "daemon"
 
 # Forgexa CLI
 

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/forgexa_cli/__init__.py

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

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/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.6"
+DAEMON_VERSION = "1.14.8"
 
 
 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,
@@ -4616,6 +4659,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,

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/forgexa_cli/main.py

@@ -162,21 +162,14 @@ def _refresh_access_token() -> bool:
     if not refresh_token:
         return False
 
-    import urllib.request
-    import urllib.error
+    import httpx
 
     url = f"{_api_url()}/api/v1/auth/refresh"
-    body = json.dumps({"refresh_token": refresh_token}).encode()
-    req = urllib.request.Request(
-        url,
-        data=body,
-        headers={"Content-Type": "application/json"},
-        method="POST",
-    )
     try:
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            payload = json.loads(resp.read())
-    except (urllib.error.HTTPError, urllib.error.URLError, json.JSONDecodeError, OSError):
+        with httpx.Client(timeout=15) as client:
+            resp = client.post(url, json={"refresh_token": refresh_token})
+            payload = resp.json()
+    except Exception:
         return False
 
     access_token = str(payload.get("access_token") or "").strip()
@@ -412,6 +405,117 @@ def _build_upgrade_plan(target_version: str | None) -> UpgradePlan:
     )
 
 
+# ── Update-check helpers ──────────────────────────────────────────────────────
+#
+# Strategy (borrowed from gh CLI / update-notifier):
+#   1. At the start of main(): launch a daemon thread that calls PyPI and
+#      writes ~/.forgexa/update-check.json (only when the cache is stale).
+#   2. At the end of main(): read the cache (instant) and, if a newer version
+#      is available, print one notice to stderr.
+#
+# Zero latency on the critical path — we never wait for the network.
+# Auto-skipped in CI, non-TTY stderr, `forgexa upgrade`, and --format json.
+
+_UPDATE_CACHE_PATH: Path = Path.home() / ".forgexa" / "update-check.json"
+_UPDATE_CHECK_TTL: int = 24 * 3600  # seconds
+
+
+def _read_update_cache() -> tuple[str | None, float]:
+    """Return (latest_version, checked_at_epoch).  Never raises."""
+    try:
+        data = json.loads(_UPDATE_CACHE_PATH.read_text())
+        version = str(data.get("latest_version") or "").strip()
+        checked_at = float(data.get("checked_at") or 0)
+        return (version or None, checked_at)
+    except Exception:
+        return (None, 0.0)
+
+
+def _write_update_cache(latest_version: str) -> None:
+    """Atomically write the update cache.  Never raises."""
+    try:
+        _UPDATE_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+        tmp = _UPDATE_CACHE_PATH.with_suffix(".json.tmp")
+        tmp.write_text(
+            json.dumps({"latest_version": latest_version, "checked_at": time.time()})
+        )
+        tmp.replace(_UPDATE_CACHE_PATH)
+    except Exception:
+        pass
+
+
+def _version_is_newer(candidate: str, reference: str) -> bool:
+    """Return True if candidate is strictly newer than reference (numeric tuple comparison)."""
+    def _parts(v: str) -> tuple[int, ...]:
+        return tuple(int(x) for x in v.split(".")[:4] if x.isdigit())
+    try:
+        return _parts(candidate) > _parts(reference)
+    except Exception:
+        return False
+
+
+def _launch_update_check_thread() -> None:
+    """Start a fire-and-forget daemon thread that fetches the latest PyPI version.
+
+    The thread only runs if the cache is stale (> TTL).  Because it is a daemon
+    thread the OS kills it automatically when the main process exits, so it never
+    delays shutdown.
+    """
+    _, checked_at = _read_update_cache()
+    if time.time() - checked_at <= _UPDATE_CHECK_TTL:
+        return  # Cache is fresh — nothing to do
+
+    import threading
+
+    def _worker() -> None:
+        try:
+            import httpx
+            with httpx.Client(timeout=5) as client:
+                resp = client.get("https://pypi.org/pypi/forgexa-cli/json")
+                latest = str(resp.json()["info"]["version"])
+            _write_update_cache(latest)
+        except Exception:
+            pass  # Network errors are silently ignored
+
+    t = threading.Thread(target=_worker, daemon=True, name="forgexa-update-check")
+    t.start()
+
+
+def _print_update_notice_if_available() -> None:
+    """Print an update notice to stderr when a newer version is cached.
+
+    Silently skipped when:
+      - FORGEXA_NO_UPDATE_CHECK=1 is set
+      - stderr is not a TTY (pipes, CI, scripts)
+      - The CI env var is set
+      - Output format is json (machine-readable)
+    """
+    if os.environ.get("FORGEXA_NO_UPDATE_CHECK"):
+        return
+    if os.environ.get("CI"):
+        return
+    if not sys.stderr.isatty():
+        return
+    if _output_format == "json":
+        return
+
+    current = _installed_cli_version()
+    if not current:
+        return
+
+    latest, _ = _read_update_cache()
+    if not latest or not _version_is_newer(latest, current):
+        return
+
+    print(
+        f"\n  Update available: forgexa {current} → {latest}\n"
+        f"  Run: forgexa upgrade\n",
+        file=sys.stderr,
+    )
+
+
+# ── Daemon PID-file helpers ───────────────────────────────────────────────────
+
 def _daemon_pid_files() -> list[Path]:
     return [
         Path.home() / ".forgexa-daemon.pid",
@@ -505,19 +609,16 @@ def _request_json(
     timeout: int = 15,
     allow_refresh: bool = True,
 ) -> dict | list | None:
-    import urllib.request
-    import urllib.error
+    import httpx
 
     url = f"{_api_url()}/api/v1{path}"
-    body = json.dumps(data).encode() if data is not None else None
-    req = urllib.request.Request(url, data=body, headers=_headers(), method=method)
     try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            content = resp.read()
-            return json.loads(content) if content else None
-    except urllib.error.HTTPError as e:
-        body_text = e.read().decode(errors="replace")
-        if e.code == 401 and allow_refresh and _refresh_access_token():
+        with httpx.Client(headers=_headers(), timeout=timeout) as client:
+            resp = client.request(method, url, json=data)
+            resp.raise_for_status()
+            return resp.json() if resp.content else None
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 401 and allow_refresh and _refresh_access_token():
             return _request_json(
                 path,
                 method=method,
@@ -525,10 +626,11 @@ def _request_json(
                 timeout=timeout,
                 allow_refresh=False,
             )
-        print(f"Error {e.code}: {body_text}", file=sys.stderr)
+        body_text = e.response.text
+        print(f"Error {e.response.status_code}: {body_text}", file=sys.stderr)
         sys.exit(1)
-    except urllib.error.URLError as e:
-        print(f"Connection error: {e.reason}\nServer: {_api_url()}", file=sys.stderr)
+    except httpx.RequestError as e:
+        print(f"Connection error: {e}\nServer: {_api_url()}", file=sys.stderr)
         sys.exit(1)
 
 
@@ -664,15 +766,14 @@ def _get_runtimes(include_all: bool = False) -> list[dict]:
 
 def _get_runtimes_silent(include_all: bool = False) -> list[dict]:
     """Like _get_runtimes() but returns [] instead of sys.exit on any error."""
-    import urllib.request
+    import httpx
 
     path = "/runtimes" if include_all else "/runtimes/me"
     url = f"{_api_url()}/api/v1{path}"
-    req = urllib.request.Request(url, headers=_headers(), method="GET")
     try:
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            content = resp.read()
-            result = json.loads(content) if content else []
+        with httpx.Client(headers=_headers(), timeout=10) as client:
+            resp = client.get(url)
+            result = resp.json() if resp.content else []
             return result if isinstance(result, list) else []
     except Exception:
         return []
@@ -1535,6 +1636,16 @@ def main() -> None:
         parser.print_help()
         return
 
+    # Start background update-check now (writes cache if stale; zero latency).
+    # Skip for `upgrade` (user is already updating) and raw log tailing
+    # (`daemon logs -f` / `logs -f`) which never returns.
+    _skip_update_check = cmd == "upgrade" or (
+        cmd in ("daemon", "logs")
+        and getattr(args, "follow", False)
+    )
+    if not _skip_update_check:
+        _launch_update_check_thread()
+
     dispatch: dict = {
         "version": cmd_version,
         "upgrade": cmd_upgrade,
@@ -1599,6 +1710,10 @@ def main() -> None:
     else:
         parser.print_help()
 
+    # Show update notice as a footer (reads local cache — no network latency).
+    if not _skip_update_check:
+        _print_update_notice_if_available()
+
 
 if __name__ == "__main__":
     main()

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.6
+Version: 1.14.8
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT
@@ -26,8 +26,10 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.24
+Requires-Dist: socksio>=1.0.0
 Provides-Extra: daemon
 Requires-Dist: httpx>=0.24; extra == "daemon"
+Requires-Dist: socksio>=1.0.0; extra == "daemon"
 
 # Forgexa CLI
 

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/forgexa_cli.egg-info/requires.txt

@@ -1,4 +1,6 @@
 httpx>=0.24
+socksio>=1.0.0
 
 [daemon]
 httpx>=0.24
+socksio>=1.0.0

{forgexa_cli-1.14.6 → forgexa_cli-1.14.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.14.6"
+version = "1.14.8"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = { text = "MIT" }
@@ -27,11 +27,13 @@ classifiers = [
 ]
 # httpx is required for the daemon (core feature). Declaring it here ensures pip/pipx
 # installs it automatically — no fragile runtime auto-install needed.
-dependencies = ["httpx>=0.24"]
+# socksio is required for SOCKS proxy support (httpx picks up ALL_PROXY/SOCKS_PROXY env vars
+# automatically, and raises ImportError if socksio is missing).
+dependencies = ["httpx>=0.24", "socksio>=1.0.0"]
 
 [project.optional-dependencies]
 # Keep [daemon] extra for backward compatibility / explicit opt-in.
-daemon = ["httpx>=0.24"]
+daemon = ["httpx>=0.24", "socksio>=1.0.0"]
 
 [project.urls]
 Homepage = "https://forgexa.net"