nova-bridgeye 0.1.0

package/nova_cli/nova_core/ai/utils.py

@@ -0,0 +1,12 @@
+# nova_cli/nova_core/ai/utils.py
+# CLI-only list for model selector UI.
+# The API remains the source of truth for what is actually allowed.
+
+MODELS = {
+    "groq": [
+        "openai/gpt-oss-120b",
+        "openai/gpt-oss-20b",
+        "meta-llama/llama-4-scout-17b-16e-instruct",
+        "moonshotai/kimi-k2-instruct-0905",
+    ],
+}

package/nova_cli/nova_core/auth/client.py

@@ -0,0 +1,103 @@
+# NOVA_CLI\nova_cli\nova_core\auth\client.py
+
+import os
+import time
+import webbrowser
+import requests
+from typing import Optional, Dict, Any
+
+
+class NovaAuthClient:
+    def __init__(self, base_url: Optional[str] = None):
+        # Priority:
+        # 1) passed base_url
+        # 2) env NOVA_AUTH_BASE_URL
+        # 3) default production
+        resolved = base_url or os.getenv("NOVA_AUTH_BASE_URL") or "https://nova.bridgeye.com"
+        self.base_url = resolved.rstrip("/")
+
+        # Basic client identity (helps audit logs + debugging)
+        self.user_agent = os.getenv("NOVA_USER_AGENT", "NovaCLI/1.0")
+
+    def _headers(self) -> Dict[str, str]:
+        return {"User-Agent": self.user_agent}
+
+    def create_session(self) -> str:
+        # Render can cold-start, keep this lenient
+        r = requests.post(
+            f"{self.base_url}/auth/session",
+            timeout=30,
+            headers=self._headers(),
+        )
+        r.raise_for_status()
+        data = r.json()
+        return data["session_id"]
+
+    def open_browser(self, session_id: str) -> None:
+        url = f"{self.base_url}/login?session_id={session_id}"
+        webbrowser.open(url)
+
+    def poll_session(self, session_id: str, timeout: int = 300) -> Optional[str]:
+        start = time.time()
+
+        while time.time() - start < timeout:
+            try:
+                r = requests.get(
+                    f"{self.base_url}/auth/session/{session_id}",
+                    timeout=10,
+                    headers=self._headers(),
+                )
+
+                if r.status_code == 200:
+                    data = r.json()
+                    if data.get("status") == "approved":
+                        return data.get("auth_code")
+
+            except Exception:
+                pass
+
+            time.sleep(2)
+
+        return None
+
+    def exchange_auth_code(self, auth_code: str) -> Dict[str, Any]:
+        try:
+            r = requests.post(
+                f"{self.base_url}/auth/token",
+                json={"auth_code": auth_code},
+                timeout=20,
+                headers=self._headers(),
+            )
+
+            if r.status_code != 200:
+                return {
+                    "error": "token_exchange_failed",
+                    "status": r.status_code,
+                    "body": r.text,
+                }
+
+            return r.json()
+
+        except Exception as e:
+            return {"error": "request_failed", "body": str(e)}
+
+    def refresh_access(self, refresh_token: str) -> Dict[str, Any]:
+        try:
+            r = requests.post(
+                f"{self.base_url}/auth/refresh",
+                json={"refresh_token": refresh_token},
+                timeout=20,
+                headers=self._headers(),
+            )
+
+            if r.status_code != 200:
+                return {
+                    "error": "refresh_failed",
+                    "status": r.status_code,
+                    "body": r.text,
+                }
+
+            return r.json()
+
+        except Exception as e:
+            return {"error": "request_failed", "body": str(e)}

package/nova_cli/nova_core/auth/storage.py

@@ -0,0 +1,146 @@
+# NOVA_CLI\nova_cli\nova_core\auth\storage.py
+
+import os
+import json
+import time
+from typing import Optional, Dict, Any
+
+AUTH_DIR = os.path.expanduser("~/.nova")
+AUTH_FILE = os.path.join(AUTH_DIR, "auth.json")
+
+DEFAULT_EXPIRES_IN = 3600
+
+
+def _now() -> float:
+    return time.time()
+
+
+def _read_json(path: str) -> Optional[Dict[str, Any]]:
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def save_auth(data: dict) -> None:
+    os.makedirs(AUTH_DIR, exist_ok=True)
+
+    # Normalize issued_at
+    if "issued_at" not in data or data["issued_at"] in (None, ""):
+        data["issued_at"] = _now()
+    else:
+        try:
+            data["issued_at"] = float(data["issued_at"])
+        except Exception:
+            data["issued_at"] = _now()
+
+    # Normalize expires_in
+    if "expires_in" in data and data["expires_in"] not in (None, ""):
+        try:
+            data["expires_in"] = int(data["expires_in"])
+        except Exception:
+            data["expires_in"] = DEFAULT_EXPIRES_IN
+    else:
+        # if missing, keep whatever is there; access expiry will be treated conservatively
+        data.setdefault("expires_in", DEFAULT_EXPIRES_IN)
+
+    with open(AUTH_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def load_auth() -> Optional[Dict[str, Any]]:
+    return _read_json(AUTH_FILE)
+
+
+def logout() -> None:
+    if os.path.exists(AUTH_FILE):
+        os.remove(AUTH_FILE)
+
+
+def has_refresh_token() -> bool:
+    data = load_auth()
+    return bool(data and data.get("refresh_token"))
+
+
+def _access_expired(data: Dict[str, Any]) -> bool:
+    access = data.get("access_token")
+    if not access:
+        return True
+
+    expires_in = data.get("expires_in")
+    issued_at = data.get("issued_at")
+
+    # If metadata missing, treat as expired so client will refresh safely.
+    if expires_in in (None, "", 0) or issued_at in (None, ""):
+        return True
+
+    try:
+        exp_ts = float(issued_at) + float(expires_in)
+    except Exception:
+        return True
+
+    return _now() >= exp_ts
+
+
+def is_logged_in() -> bool:
+    """
+    Logged-in means we have either:
+      - a non-expired access token, OR
+      - a refresh token (so we can get a new access token)
+    """
+    data = load_auth()
+    if not data:
+        return False
+
+    if data.get("refresh_token"):
+        return True
+
+    # no refresh token -> must have valid access
+    return not _access_expired(data)
+
+
+def get_access_token() -> Optional[str]:
+    data = load_auth()
+    if not data:
+        return None
+
+    if _access_expired(data):
+        return None
+
+    return data.get("access_token")
+
+
+def get_refresh_token() -> Optional[str]:
+    data = load_auth()
+    if not data:
+        return None
+    return data.get("refresh_token")
+
+
+def update_tokens(
+    access_token: str,
+    refresh_token: str,
+    expires_in: int = DEFAULT_EXPIRES_IN,
+    issued_at: Optional[float] = None,
+) -> None:
+    data = load_auth() or {}
+    data["access_token"] = access_token
+    data["refresh_token"] = refresh_token
+    data["expires_in"] = int(expires_in) if expires_in else DEFAULT_EXPIRES_IN
+    data["issued_at"] = float(issued_at) if issued_at else _now()
+    save_auth(data)
+
+
+def update_access_token(
+    access_token: str,
+    expires_in: int = DEFAULT_EXPIRES_IN,
+    issued_at: Optional[float] = None,
+) -> None:
+    data = load_auth() or {}
+    data["access_token"] = access_token
+    data["expires_in"] = int(expires_in) if expires_in else DEFAULT_EXPIRES_IN
+    data["issued_at"] = float(issued_at) if issued_at else _now()
+    save_auth(data)

package/nova_legacy.py

@@ -0,0 +1,15 @@
+import logging
+
+from nova.CLI.shell import NovaShell
+
+# --- LOGGING SETUP ---
+logging.basicConfig(
+    filename='nova.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+
+if __name__ == "__main__":
+    app = NovaShell()
+    app.run()  

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "nova-bridgeye",
+  "version": "0.1.0",
+  "description": "NOVA CLI (Developer Teammate in your Terminal)",
+  "main": "index.js",
+  "bin": {
+    "nova": "./bin/nova"
+  },
+  "scripts": {
+    "postinstall": "pip3 install nova-bridgeye || pip install nova-bridgeye"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bridgeyeai/NOVA-CLI.git"
+  },
+  "keywords": ["nova", "bridgeye", "cli", "ai"],
+  "author": "Bridgeye",
+  "license": "MIT"
+}