forgexa-cli 1.4.2__tar.gz → 1.5.2__tar.gz

{forgexa_cli-1.4.2 → forgexa_cli-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.4.2
+Version: 1.5.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.4.2 → forgexa_cli-1.5.2}/forgexa_cli/__init__.py

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

{forgexa_cli-1.4.2 → forgexa_cli-1.5.2}/forgexa_cli/daemon.py

@@ -279,6 +279,10 @@ except (ImportError, ModuleNotFoundError):
         def AGENT_TIMEOUT(self) -> int:
             return int(os.environ.get("AGENT_TIMEOUT", "3600"))
 
+        @property
+        def GIT_CLONE_TIMEOUT(self) -> int:
+            return int(os.environ.get("GIT_CLONE_TIMEOUT", "600"))
+
         @property
         def AGENT_MAX_OUTPUT_SIZE(self) -> int:
             return int(os.environ.get("AGENT_MAX_OUTPUT_SIZE", "100000"))
@@ -303,7 +307,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.4.2"
+DAEMON_VERSION = "1.5.2"
 
 
 def _detect_client_type() -> str:
@@ -1085,7 +1089,10 @@ class WorkspaceManager:
 
         # Ensure _main repo is present and up-to-date
         if not main_repo.exists():
-            await self._git("clone", repo_url, str(main_repo), timeout=600, project_key=project_key)
+            await self._git(
+                "clone", "--single-branch", "--no-tags",
+                repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+            )
         else:
             await self._git("fetch", "--all", cwd=main_repo, timeout=300, project_key=project_key)
 
@@ -1173,7 +1180,10 @@ class WorkspaceManager:
                         )
                     except Exception:
                         ws_path.mkdir(parents=True, exist_ok=True)
-                        await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                        await self._git(
+                            "clone", "--single-branch", "--no-tags",
+                            repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                        )
                         # Ensure we're on the correct branch after clone
                         try:
                             await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -1195,7 +1205,10 @@ class WorkspaceManager:
                 except Exception:
                     # Fallback to simple clone
                     ws_path.mkdir(parents=True, exist_ok=True)
-                    await self._git("clone", repo_url, str(ws_path), project_key=project_key)
+                    await self._git(
+                        "clone", "--single-branch", "--no-tags",
+                        repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
+                    )
                     # Ensure we're on the correct branch after clone
                     try:
                         await self._git("checkout", "-B", branch_name, cwd=ws_path)
@@ -1422,21 +1435,29 @@ class ProcessManager:
         Returns True for rate/quota limits AND API unavailability errors,
         since a different agent (using a different API backend) may succeed.
 
-        IMPORTANT: Only checks stderr, error message, and the tail of stdout.
-        The full stdout contains the agent's work output (e.g., analysis text
-        about APIs, retry logic, HTTP status codes) which naturally contains
-        patterns like "429", "try again", "capacity" — these are NOT indicators
-        of the agent CLI itself being rate-limited.
+        IMPORTANT: Only checks stderr and error message.  When exit code is
+        non-zero, also checks the tail of stdout (last 3000 chars) since the
+        error is likely at the end.  When exit code is 0 (agent reported
+        success but _detect_agent_output_failure set status to failed), do
+        NOT scan stdout — it contains the agent's work output (configs, code)
+        which naturally has terms like "rate_limit", "API_RATE_LIMIT_PER_MINUTE"
+        that trigger false positives.
         """
         if result.status == "success":
             return False
-        # Search error channels: stderr (CLI errors) + error message + tail of stdout
-        # (last 3000 chars catches any CLI-level error at the end of output)
-        error_text = (
-            (result.stderr or "")
-            + "\n" + (result.error or "")
-            + "\n" + (result.stdout or "")[-3000:]
-        ).lower()
+        # When exit code is 0, _detect_agent_output_failure already checked
+        # stderr+error for rate-limit patterns.  Don't re-scan stdout here.
+        if result.exit_code == 0:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+            ).lower()
+        else:
+            error_text = (
+                (result.stderr or "")
+                + "\n" + (result.error or "")
+                + "\n" + (result.stdout or "")[-3000:]
+            ).lower()
         return (
             any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS)
             or any(p in error_text for p in ProcessManager.AGENT_UNAVAILABLE_PATTERNS)
@@ -1456,16 +1477,16 @@ class ProcessManager:
         if result.status != "success":
             return None
 
-        # For rate/unavailability pattern detection, only check error channels
-        # (stderr, error field) plus the TAIL of stdout.  The full stdout contains
-        # the agent's work output (analysis text, generated docs) which naturally
-        # mentions terms like "rate limit", "429", "capacity", "credit" etc.
-        error_channels = (
-            (result.stderr or "")
-            + "\n" + (result.error or "")
-            + "\n" + (result.stdout or "")[-3000:]
-        )
-        pattern_failure = ProcessManager._has_failure_pattern(error_channels)
+        # For exit-code-0 (success) cases, only scan stderr and the error field
+        # for rate-limit / unavailability patterns.  Stdout contains the agent's
+        # actual task output (code, configs, analysis docs) which may legitimately
+        # contain substrings like "rate_limit", "429", "quota", etc. — e.g. writing
+        # a config file with API_RATE_LIMIT_PER_MINUTE=1000 would previously trigger
+        # a false "quota exhaustion" failure even though the agent succeeded.
+        # stdout[-N:] is only safe to scan when the agent already failed (exit != 0),
+        # which is handled by is_rate_limited() called at the orchestrator level.
+        error_only_channels = (result.stderr or "") + "\n" + (result.error or "")
+        pattern_failure = ProcessManager._has_failure_pattern(error_only_channels)
         if pattern_failure:
             return pattern_failure
 
@@ -1849,7 +1870,13 @@ class ProcessManager:
         on_chunk: Any = None,
     ) -> TaskResult:
         """Run OpenCode CLI in non-interactive mode."""
-        cmd = [agent.command, "run", "--format", "json", "--dangerously-skip-permissions", prompt]
+        cmd = [
+            agent.command, "run",
+            "--format", "json",
+            "--dangerously-skip-permissions",
+            "--cwd", str(cwd),
+            prompt,
+        ]
         result = await self._run_cli(cmd, cwd, timeout, task_id, on_chunk=on_chunk)
         parsed_metrics = self._parse_agent_jsonl_output(result.stdout)
         result.metrics.update(parsed_metrics)

{forgexa_cli-1.4.2 → forgexa_cli-1.5.2}/forgexa_cli/main.py

@@ -4,17 +4,20 @@ Forgexa CLI — command-line client for the Forgexa platform.
 A lightweight, standalone CLI that communicates with the Forgexa server via REST API.
 Zero external dependencies — uses only Python stdlib.
 
-Configuration:
-    FORGEXA_SERVER_URL   Server URL (default: https://api.forgexa.net)
-    FORGEXA_TOKEN        Bearer token (obtain via `forgexa login`)
+Configuration (in priority order):
+    1. --server-url flag          Per-command override
+    2. FORGEXA_SERVER_URL env var  Session-level override
+    3. ~/.forgexa/config          Saved via `forgexa login --server <url>`
+    4. Build default              https://api.forgexa.net
 
 Usage:
-    forgexa login
+    forgexa login --server https://your-server.com
     forgexa workspace list
     forgexa project list --workspace <id>
     forgexa requirement list --project <id>
     forgexa daemon status
     forgexa gates pending
+    forgexa config show
     forgexa --help
 """
 from __future__ import annotations
@@ -27,23 +30,56 @@ import signal
 import sys
 from pathlib import Path
 
-# ── HTTP helpers (stdlib only) ──
+# ── Build-time default ──
+# Resolved in priority order at runtime (see _api_url()):
+#   1. --server-url flag
+#   2. FORGEXA_SERVER_URL environment variable
+#   3. ~/.forgexa/config  (saved by `forgexa login --server <url>`)
+#   4. This build default
 
-
-# Default server URL — resolved in priority order:
-#   1. FORGEXA_SERVER_URL environment variable (runtime override)
-#   2. _build_config.py   — generated by publish.sh at wheel-build time
-#   3. Hardcoded fallback — https://api.forgexa.net
-#
-# For local development use: FORGEXA_SERVER_URL=http://localhost:8000 forgexa ...
 try:
-    from forgexa_cli._build_config import BUILD_SERVER_URL as _DEFAULT_SERVER_URL
+    from forgexa_cli._build_config import BUILD_SERVER_URL as _BUILD_DEFAULT
 except ImportError:
-    _DEFAULT_SERVER_URL = "https://api.forgexa.net"
+    _BUILD_DEFAULT = "https://api.forgexa.net"
+
+# Module-level override applied by main() when --server-url is passed.
+_SERVER_URL_OVERRIDE: str | None = None
+
+
+# ── Config file helpers (~/.forgexa/config) ──
+
+def _config_path() -> Path:
+    return Path.home() / ".forgexa" / "config"
+
+
+def _load_config() -> dict:
+    p = _config_path()
+    if p.exists():
+        try:
+            return json.loads(p.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_config(data: dict) -> None:
+    p = _config_path()
+    p.parent.mkdir(exist_ok=True)
+    p.write_text(json.dumps(data, indent=2))
+    p.chmod(0o600)
 
 
 def _api_url() -> str:
-    return os.environ.get("FORGEXA_SERVER_URL", _DEFAULT_SERVER_URL)
+    """Resolve the server URL using priority chain."""
+    if _SERVER_URL_OVERRIDE:
+        return _SERVER_URL_OVERRIDE
+    env = os.environ.get("FORGEXA_SERVER_URL")
+    if env:
+        return env
+    cfg = _load_config()
+    if cfg.get("server_url"):
+        return cfg["server_url"]
+    return _BUILD_DEFAULT
 
 
 def _token() -> str | None:
@@ -53,7 +89,8 @@ def _token() -> str | None:
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         return token_file.read_text().strip()
-    return None
+    cfg = _load_config()
+    return cfg.get("token") or None
 
 
 def _headers() -> dict[str, str]:
@@ -157,26 +194,83 @@ def _print_table(headers: list[str], rows: list[list[str]], fmt: str | None = No
 
 
 def cmd_login(args: argparse.Namespace) -> None:
+    # If --server was given, apply it for this login request and save it.
+    server = getattr(args, "server", None)
+    if server:
+        global _SERVER_URL_OVERRIDE
+        _SERVER_URL_OVERRIDE = server.rstrip("/")
+
     email = args.email or input("Email: ")
     password = args.password or getpass.getpass("Password: ")
     result = _post("/auth/login", {"email": email, "password": password})
     token = result.get("access_token", "")
-    # Save token to file
+
+    # Save to config file (server_url + token in one place)
+    cfg = _load_config()
+    if server:
+        cfg["server_url"] = _SERVER_URL_OVERRIDE
+    cfg["token"] = token
+    _save_config(cfg)
+
+    # Also keep the legacy token file for backwards compatibility
     token_dir = Path.home() / ".forgexa"
     token_dir.mkdir(exist_ok=True)
     (token_dir / "token").write_text(token)
     (token_dir / "token").chmod(0o600)
-    print(f"Login successful. Token saved to ~/.forgexa/token")
-    print(f"Or set manually: export FORGEXA_TOKEN={token}")
+
+    active_server = _api_url()
+    print(f"Login successful.")
+    print(f"  Server : {active_server}")
+    print(f"  Config : ~/.forgexa/config")
 
 
 def cmd_logout(_args: argparse.Namespace) -> None:
+    cleared = False
     token_file = Path.home() / ".forgexa" / "token"
     if token_file.exists():
         token_file.unlink()
+        cleared = True
+    cfg = _load_config()
+    if "token" in cfg:
+        del cfg["token"]
+        _save_config(cfg)
+        cleared = True
+    if cleared:
         print("Logged out. Token removed.")
     else:
-        print("No token file found.")
+        print("No token found.")
+
+
+def cmd_config_show(_args: argparse.Namespace) -> None:
+    """Show current CLI configuration."""
+    cfg = _load_config()
+    token = _token()
+    active_url = _api_url()
+    source = "build default"
+    if _SERVER_URL_OVERRIDE:
+        source = "--server-url flag"
+    elif os.environ.get("FORGEXA_SERVER_URL"):
+        source = "FORGEXA_SERVER_URL env var"
+    elif cfg.get("server_url"):
+        source = f"~/.forgexa/config"
+    print(f"Server URL : {active_url}  (source: {source})")
+    print(f"Auth token : {'set' if token else 'not set'}")
+    print(f"Config file: {_config_path()}")
+
+
+def cmd_config_set(args: argparse.Namespace) -> None:
+    """Set a configuration value."""
+    cfg = _load_config()
+    if args.key == "server-url":
+        url = args.value.rstrip("/")
+        cfg["server_url"] = url
+        _save_config(cfg)
+        print(f"Server URL set to: {url}")
+        print(f"Saved to: {_config_path()}")
+    else:
+        print(f"Unknown config key: {args.key}", file=sys.stderr)
+        print("Available keys: server-url", file=sys.stderr)
+        sys.exit(1)
 
 
 def cmd_daemon_status(_args: argparse.Namespace) -> None:
@@ -467,20 +561,28 @@ def cmd_version(_args: argparse.Namespace) -> None:
 
 
 def main() -> None:
+    global _SERVER_URL_OVERRIDE, _output_format
+
+    active_url = _api_url()  # resolved before parsing (for help text)
+
     parser = argparse.ArgumentParser(
         prog="forgexa",
         description="Forgexa CLI — communicates with the Forgexa server via REST API.",
         epilog=(
             "Configuration:\n"
-            f"  FORGEXA_SERVER_URL   Server URL (default: {_DEFAULT_SERVER_URL})\n"
-            "  FORGEXA_TOKEN        Bearer token (or use `forgexa login`)\n"
+            f"  Current server : {active_url}\n"
+            "  Change server  : forgexa login --server <url>\n"
+            "                   forgexa config set server-url <url>\n"
+            "                   export FORGEXA_SERVER_URL=<url>\n"
+            "  Auth token     : forgexa login  (saved to ~/.forgexa/config)\n"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument(
         "--server-url",
         default=None,
-        help=f"Server URL (default: $FORGEXA_SERVER_URL or {_DEFAULT_SERVER_URL})",
+        metavar="URL",
+        help="Server URL override for this command (also: $FORGEXA_SERVER_URL or ~/.forgexa/config)",
     )
     parser.add_argument(
         "--format",
@@ -495,10 +597,19 @@ def main() -> None:
 
     # auth
     login_p = sub.add_parser("login", help="Login and save access token")
+    login_p.add_argument("--server", metavar="URL", help="Server URL to connect to (saved to ~/.forgexa/config)")
     login_p.add_argument("--email", help="Email address")
     login_p.add_argument("--password", help="Password")
     sub.add_parser("logout", help="Remove saved access token")
 
+    # config
+    config_p = sub.add_parser("config", help="View or change CLI configuration")
+    config_sub = config_p.add_subparsers(dest="config_cmd")
+    config_sub.add_parser("show", help="Show current configuration")
+    cfg_set = config_sub.add_parser("set", help="Set a configuration value")
+    cfg_set.add_argument("key", choices=["server-url"], help="Config key")
+    cfg_set.add_argument("value", help="Config value")
+
     # daemon (remote API only — use forgexa-daemon for local daemon management)
     daemon_p = sub.add_parser("daemon", help="Daemon management")
     daemon_sub = daemon_p.add_subparsers(dest="daemon_cmd")
@@ -583,9 +694,8 @@ def main() -> None:
     args = parser.parse_args()
 
     if args.server_url:
-        os.environ["FORGEXA_SERVER_URL"] = args.server_url
+        _SERVER_URL_OVERRIDE = args.server_url.rstrip("/")
 
-    global _output_format
     _output_format = args.format or "table"
 
     cmd = args.command
@@ -597,6 +707,10 @@ def main() -> None:
         "version": cmd_version,
         "login": cmd_login,
         "logout": cmd_logout,
+        "config": lambda a: {
+            "show": cmd_config_show,
+            "set": cmd_config_set,
+        }.get(a.config_cmd, lambda _: config_p.print_help())(a),
         "daemon": lambda a: {
             "start": cmd_daemon_start,
             "status": cmd_daemon_status,

{forgexa_cli-1.4.2 → forgexa_cli-1.5.2}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.4.2
+Version: 1.5.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.4.2 → forgexa_cli-1.5.2}/pyproject.toml

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