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

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

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

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

{forgexa_cli-1.14.6 → forgexa_cli-1.14.7}/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.7"
 
 
 def _detect_client_type() -> str:

{forgexa_cli-1.14.6 → forgexa_cli-1.14.7}/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.7}/forgexa_cli.egg-info/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.14.6"
+version = "1.14.7"
 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"