@agxnte/reidx 2.0.5 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agxnte/reidx",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "Terminal-native personal intelligence and coding CLI (agent-first runtime)",
   "bin": {
     "reid": "bin/reidx.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reidx"
-version = "2.0.5"
+version = "2.0.6"
 description = "Terminal-native personal intelligence and coding CLI (agent-first runtime)"
 readme = "README.md"
 requires-python = ">=3.12"

package/src/reidx/__init__.py

@@ -1,3 +1,3 @@
 """ReidX: terminal-native agent-first CLI runtime."""
 
-__version__ = "2.0.5"
+__version__ = "2.0.6"

package/src/reidx/provider/_http.py

@@ -1,42 +1,75 @@
-"""Shared HTTP helper for provider clients — stdlib urllib, no extra deps."""
-from __future__ import annotations
-
-import json
-import urllib.error
-import urllib.request
-
-TIMEOUT_SECONDS = 120
-
-
-def post_json(url: str, payload: dict, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
-    """POST a JSON payload, return the parsed JSON response.
-
-    Raises RuntimeError on HTTP or network errors — providers surface those
-    to the agent loop, which turns them into tool-result errors rather than
-    crashing the turn.
-    """
-    body = json.dumps(payload).encode("utf-8")
-    hdrs = {"content-type": "application/json", **headers}
-    req = urllib.request.Request(url, data=body, headers=hdrs, method="POST")
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        err_body = exc.read().decode("utf-8", errors="replace")[:500]
-        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
-    except urllib.error.URLError as exc:
-        raise RuntimeError(f"connection error: {exc}") from exc
-    return json.loads(raw)
-
-
-def get_json(url: str, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
-    req = urllib.request.Request(url, headers=headers, method="GET")
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        err_body = exc.read().decode("utf-8", errors="replace")[:500]
-        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
-    except urllib.error.URLError as exc:
-        raise RuntimeError(f"connection error: {exc}") from exc
-    return json.loads(raw)
+"""Shared HTTP helper for provider clients — stdlib urllib, no extra deps."""
+from __future__ import annotations
+
+import json
+import os
+import ssl
+import urllib.error
+import urllib.request
+
+TIMEOUT_SECONDS = 120
+
+_SSL_CONTEXT: ssl.SSLContext | None = None
+
+
+def _build_ssl_context() -> ssl.SSLContext:
+    insecure = os.environ.get("REIDX_INSECURE", "").strip().lower() in ("1", "true", "yes", "on")
+    if insecure:
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+    try:
+        import certifi
+        return ssl.create_default_context(cafile=certifi.where())
+    except ImportError:
+        pass
+
+    ctx = ssl.create_default_context()
+    try:
+        ctx.load_default_certs(ssl.Purpose.SERVER_AUTH)
+    except ssl.SSLError:
+        pass
+    return ctx
+
+
+def _ssl_ctx() -> ssl.SSLContext:
+    global _SSL_CONTEXT
+    if _SSL_CONTEXT is None:
+        _SSL_CONTEXT = _build_ssl_context()
+    return _SSL_CONTEXT
+
+
+def post_json(url: str, payload: dict, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
+    """POST a JSON payload, return the parsed JSON response.
+
+    Raises RuntimeError on HTTP or network errors — providers surface those
+    to the agent loop, which turns them into tool-result errors rather than
+    crashing the turn.
+    """
+    body = json.dumps(payload).encode("utf-8")
+    hdrs = {"content-type": "application/json", **headers}
+    req = urllib.request.Request(url, data=body, headers=hdrs, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_ctx()) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", errors="replace")[:500]
+        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"connection error: {exc}") from exc
+    return json.loads(raw)
+
+
+def get_json(url: str, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
+    req = urllib.request.Request(url, headers=headers, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_ctx()) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", errors="replace")[:500]
+        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"connection error: {exc}") from exc
+    return json.loads(raw)

package/src/reidx/provider/store.py

@@ -127,7 +127,10 @@ class ProviderStore:
         return True
 
 
-def validate_provider(record: ProviderRecord) -> tuple[bool, str]:
+def validate_provider(
+    record: ProviderRecord,
+    skip_verify: bool = False,
+) -> tuple[bool, str]:
     try:
         provider = build_provider(record)
     except (ValueError, TypeError) as exc:
@@ -137,15 +140,22 @@ def validate_provider(record: ProviderRecord) -> tuple[bool, str]:
         return False, "API key required for this provider kind"
     if not record.api_key:
         return True, "no key required"
+    if skip_verify:
+        return True, "verification skipped"
     try:
         models = provider.fetch_models()
+    except RuntimeError as exc:
+        msg = str(exc)
+        if msg.startswith("HTTP 401") or msg.startswith("HTTP 403"):
+            return False, f"authentication failed ({msg})"
+        if msg.startswith("HTTP "):
+            return False, f"provider error: {msg}"
+        return False, f"{msg} (use --skip-verify to save anyway)"
     except Exception as exc:
-        return False, f"could not connect to provider: {exc}"
+        return False, f"unexpected error: {exc} (use --skip-verify to save anyway)"
     if models:
         return True, f"ok ({len(models)} models available)"
-    if record.kind == "ollama":
-        return True, "connected"
-    return False, "key rejected or no models returned"
+    return True, "connected (no models endpoint or empty list)"
 
 
 def load_into(registry: ProviderRegistry, storage_root: Path) -> list[str]:

package/src/reidx/provider_manager/palette.py

@@ -610,8 +610,14 @@ class ProviderPalette:
             )
             ok, msg = validate_provider(record)
             if not ok:
-                self._show_message(f"Key validation failed: {msg}", self.WIZARD)
-                self.wizard_step_idx = len(WIZARD_STEPS) - 1
+                self._confirm_text = f"Key validation failed: {msg}\nSave anyway?"
+                self._pending_action = lambda: self._commit_wizard_provider(
+                    name, kind, base_url, model, auth, api_key, forced_msg=msg,
+                )
+                self.screen = self.CONFIRM
+                self.selected_index = 0
+                self._scroll_offset = 0
+                self._invalidate()
                 return
             if not model:
                 try:
@@ -622,6 +628,18 @@ class ProviderPalette:
                 if models:
                     model = models[0]
 
+        self._commit_wizard_provider(name, kind, base_url, model, auth, api_key)
+
+    def _commit_wizard_provider(
+        self,
+        name: str,
+        kind: str,
+        base_url: str,
+        model: str,
+        auth: str,
+        api_key: str,
+        forced_msg: str = "",
+    ) -> str:
         existing = self.db.get_provider(name)
         if existing:
             existing.kind = kind
@@ -660,7 +678,9 @@ class ProviderPalette:
         self.wizard_data = {}
         self.wizard_step_idx = 0
         self.input_is_password = False
-        self._close(f"Saved provider '{name}' ({kind})")
+        note = " (unverified)" if forced_msg else ""
+        self._close(f"Saved provider '{name}' ({kind}){note}")
+        return f"Saved provider '{name}'"
 
     def _do_add_key(self, label: str, api_key: str) -> None:
         if not self.current_provider:
@@ -673,13 +693,25 @@ class ProviderPalette:
             auth_method=sp.auth_method,
         )
         ok, msg = validate_provider(record)
-        if not ok:
-            self._show_message(f"Key validation failed: {msg}", self.MANAGE)
+        if ok:
+            self._commit_key(label, api_key, msg)
             return
+        self._confirm_text = f"Key validation failed: {msg}\nSave anyway?"
+        self._pending_action = lambda: self._commit_key(label, api_key, "saved (unverified)")
+        self.screen = self.CONFIRM
+        self.selected_index = 0
+        self._scroll_offset = 0
+        self._invalidate()
+
+    def _commit_key(self, label: str, api_key: str, msg: str) -> str:
+        if not self.current_provider:
+            return "Error: no provider"
+        name = self.current_provider.name
         self.db.add_key(name, label, api_key)
         self.current_provider = self.db.get_provider(name)
         self._register_current()
         self._show_message(f"Added key '{label}' ({msg})", self.MANAGE)
+        return f"Added key '{label}'"
 
     def _do_delete_key(self, key_id: str, label: str) -> str:
         if not self.current_provider:

package/src/reidx/ui/commands.py

@@ -536,10 +536,17 @@ def _handle_providers(orchestrator: Orchestrator) -> None:
 
 
 def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
-    parts = arg.split()
+    skip_verify = False
+    tokens = arg.split()
+    parts: list[str] = []
+    for tok in tokens:
+        if tok in ("--skip-verify", "--skip", "--no-verify"):
+            skip_verify = True
+        else:
+            parts.append(tok)
     if len(parts) < 3:
         render.print_error(
-            "usage: /connect <name> <kind> <base_url> [api_key] [model]  "
+            "usage: /connect <name> <kind> <base_url> [api_key] [model] [--skip-verify]  "
             f"(kind: {'|'.join(SUPPORTED_KINDS)})"
         )
         return
@@ -554,7 +561,7 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
     model = parts[4] if len(parts) > 4 else ""
     record = ProviderRecord(name=name, kind=kind, base_url=base_url, api_key=api_key, default_model=model)
     if api_key:
-        ok, msg = validate_provider(record)
+        ok, msg = validate_provider(record, skip_verify=skip_verify)
         if not ok:
             render.print_error(f"key validation failed: {msg}")
             return
@@ -564,7 +571,7 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
     except ValueError as exc:
         render.print_error(f"failed to build provider: {exc}")
         return
-    if not model and api_key:
+    if not model and api_key and not skip_verify:
         try:
             models = provider.fetch_models()
         except Exception: