ravmem-cli 1.2.0__tar.gz → 1.3.0__tar.gz

{ravmem_cli-1.2.0/ravmem_cli.egg-info → ravmem_cli-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.2.0
+Version: 1.3.0
 Summary: RavMem CLI — lightweight client for the RavMem code knowledge graph server
 Author-email: RavMem <harpreet.singh@ravmem.com>
 License-Expression: MIT

{ravmem_cli-1.2.0 → ravmem_cli-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ravmem-cli"
-version = "1.2.0"
+version = "1.3.0"
 description = "RavMem CLI — lightweight client for the RavMem code knowledge graph server"
 readme = "README.md"
 requires-python = ">=3.10"

{ravmem_cli-1.2.0 → ravmem_cli-1.3.0}/ravmem/cli/license.py

@@ -47,7 +47,7 @@ def _post_with_key_fallback(client, con: Console, path: str, body: Optional[dict
     try:
         return client.post(path, json=body)
     except RavMemAPIError as exc:
-        if exc.status == 400 and "RAVMEM_LICENSE_KEY is not set" in (exc.detail or ""):
+        if exc.status == 400 and "RAVMEM_LICENSE_KEY is not set" in (exc.detail or "") and not body.get("license_key"):
             con.print("[yellow]Server has no license key on file — enter it to proceed.[/yellow]")
             key = typer.prompt("License key", hide_input=True).strip()
             if not key:
@@ -57,6 +57,37 @@ def _post_with_key_fallback(client, con: Console, path: str, body: Optional[dict
         raise
 
 
+def _license_hint(detail: str) -> Optional[str]:
+    """Map a license-server refusal to the concrete next step for the operator."""
+    d = detail or ""
+    if "LICENSE_REVOKED" in d:
+        return ("This license was revoked. Rotate the key in the console (that un-revokes it and "
+                "issues a new key), then run: ravmem license activate <new-key>")
+    if "LICENSE_KEY_NOT_FOUND" in d or "License key not found" in d or "No account found" in d:
+        return ("The license server doesn't recognise this key. If it was rotated in the console, "
+                "run: ravmem license activate <new-key>")
+    if "ACTIVATION_LIMIT_REACHED" in d:
+        return ("Every seat on this license is in use — possibly by this same machine under a "
+                "previous key. Deactivate the old machine in the console, then retry.")
+    if "SUBSCRIPTION_SUSPENDED" in d:
+        return "The subscription is suspended. Resolve billing in the console, then run: ravmem license renew"
+    if "SUBSCRIPTION_EXPIRED" in d:
+        return "The subscription has expired. Renew it in the console, then run: ravmem license renew"
+    if "No license record found" in d:
+        return "Run: ravmem license activate <key>"
+    return None
+
+
+def _fail(con: Console, prefix: str, exc: Exception, note: Optional[str] = None) -> None:
+    con.print(f"[red]{prefix}: {exc}[/red]")
+    if note:
+        con.print(f"[dim]{note}[/dim]")
+    hint = _license_hint(getattr(exc, "detail", "") or str(exc))
+    if hint:
+        con.print(f"[yellow]-> {hint}[/yellow]")
+    raise typer.Exit(1)
+
+
 # ---------------------------------------------------------------------------
 # ravmem license init
 # ---------------------------------------------------------------------------
@@ -146,19 +177,25 @@ def activate_cmd(
     # that is fine — we just continue to the entitlement step.
     con.print("Sealing license to this machine…")
     sealed_now = False
-    try:
-        client.post("/activate", json={"license_key": key})
-        sealed_now = True
-        con.print("[green]K3 sealed. Waiting for the server to load modules…[/green]")
-    except RavMemAPIError as exc:
-        if exc.status == 404:
-            con.print("[dim]Server already activated — proceeding to entitlement init.[/dim]")
-        else:
-            con.print(f"[red]Activation failed: {exc}[/red]")
+    for attempt in range(3):
+        try:
+            client.post("/activate", json={"license_key": key})
+            sealed_now = True
+            con.print("[green]K3 sealed. Waiting for the server to load modules…[/green]")
+            break
+        except RavMemAPIError as exc:
+            if exc.status == 404:
+                con.print("[dim]Server already activated — proceeding to entitlement init.[/dim]")
+                break
+            _fail(con, "Activation failed", exc)
+        except Exception as exc:
+            # Transient: server still booting, or a network blip to it.
+            if attempt < 2:
+                time.sleep(3)
+                continue
+            con.print(f"[red]Could not reach the server: {exc}[/red]")
+            con.print("[yellow]-> Check it's running ('docker logs ravmem'), then retry.[/yellow]")
             raise typer.Exit(1)
-    except Exception as exc:
-        con.print(f"[red]Could not reach the server: {exc}[/red]")
-        raise typer.Exit(1)
 
     # Phase 2 — wait for the re-exec'd full server to finish loading modules.
     if sealed_now:
@@ -181,44 +218,57 @@ def activate_cmd(
 
     # Phase 3 — store the signed entitlement JWT (idempotent: 409 = already done).
     con.print("Activating entitlements…")
-    init_payload: dict = {"key_hash": key_hash}
+    init_payload: dict = {"key_hash": key_hash, "license_key": key}
     if server_url:
         init_payload["server_url"] = server_url
     try:
         result = client.post("/api/license/init", json=init_payload)
     except RavMemAPIError as exc:
-        if exc.status == 409:
-            # Already initialized — a 409 alone doesn't mean the stored token is
-            # still usable (e.g. a container recreate can make it undecryptable).
-            # Check token_integrity and repair if it isn't "ok" before declaring
-            # success.
-            con.print("[dim]License already initialized — verifying token integrity…[/dim]")
-            try:
-                status_data = client.get("/api/license/status")
-            except RavMemAPIError as exc2:
-                con.print(f"[red]Could not verify license status: {exc2}[/red]")
-                raise typer.Exit(1)
+        if exc.status != 409:
+            _fail(con, "Entitlement init failed", exc)
+
+        # Already initialized. That alone doesn't mean everything is fine: the
+        # stored token may be broken (recreate), the license may be
+        # deactivated/revoked, or the key typed here may differ from the one
+        # this server holds (rotated key, or a typo). Only report "ready" when
+        # all three check out; otherwise re-fetch with the key given here —
+        # the license server validates it either way, and on refusal nothing
+        # stored locally is changed.
+        con.print("[dim]License already initialized — verifying…[/dim]")
+        try:
+            status_data = client.get("/api/license/status")
+        except RavMemAPIError as exc2:
+            _fail(con, "Could not verify license status", exc2)
 
-            integrity = status_data.get("token_integrity")
-            if integrity == "ok":
-                con.print("[bold green]License already initialized — ravmem is ready.[/bold green]")
-                return
+        integrity = status_data.get("token_integrity")
+        status = status_data.get("status")
+        stored_prefix = status_data.get("key_hash_prefix")
+        key_differs = bool(stored_prefix) and not key_hash.startswith(stored_prefix)
 
-            con.print(f"[yellow]Stored token integrity is '{integrity}' — repairing…[/yellow]")
-            try:
-                # Already have the key in scope from this activate call — no
-                # need to prompt again even if the server has nothing on file.
-                repair_result = client.post("/api/license/repair", json={"license_key": key})
-            except RavMemAPIError as exc3:
-                con.print(f"[red]Repair failed: {exc3}[/red]")
-                raise typer.Exit(1)
-
-            con.print("\n[bold green]License repaired. ravmem is ready.[/bold green]")
-            con.print(f"  Status:  {repair_result.get('status')}")
-            con.print(f"  Expires: {repair_result.get('expiry_ts')}")
+        if integrity == "ok" and status in ("ACTIVE", "GRACE_PERIOD") and not key_differs:
+            con.print("[bold green]License already initialized — ravmem is ready.[/bold green]")
             return
-        con.print(f"[red]Entitlement init failed: {exc}[/red]")
-        raise typer.Exit(1)
+
+        if key_differs:
+            con.print("[yellow]This key differs from the one this server is activated with — "
+                      "switching to it…[/yellow]")
+        elif status not in ("ACTIVE", "GRACE_PERIOD"):
+            con.print(f"[yellow]License status is {status} — re-activating…[/yellow]")
+        else:
+            con.print(f"[yellow]Stored token integrity is '{integrity}' — repairing…[/yellow]")
+        try:
+            repair_result = client.post("/api/license/repair", json={"license_key": key})
+        except RavMemAPIError as exc3:
+            _fail(con, "Activation failed", exc3,
+                  note="Your existing license on this server was left unchanged." if key_differs else None)
+
+        if repair_result.get("status") == "rebind_pending":
+            con.print(f"[yellow]{repair_result.get('message')}[/yellow]")
+            raise typer.Exit(1)
+        con.print("\n[bold green]License activated. ravmem is ready.[/bold green]")
+        con.print(f"  Status:  {repair_result.get('status')}")
+        con.print(f"  Expires: {repair_result.get('expiry_ts')}")
+        return
 
     con.print("\n[bold green]License activated. ravmem is ready.[/bold green]")
     con.print(f"  Status:  {result.get('status')}")
@@ -382,6 +432,8 @@ def status_cmd(
     expiry_ts = data.get("expiry_ts")
     table.add_row("Expires", _fmt_ts(expiry_ts) + _days_until(expiry_ts))
     table.add_row("Last heartbeat", _fmt_ts(data.get("last_heartbeat")))
+    if data.get("heartbeat_interval"):
+        table.add_row("Heartbeat every", f"{data['heartbeat_interval']}s (set in the license console)")
     table.add_row("Last server time", _fmt_ts(data.get("last_server_time")))
 
     grace_deadline = data.get("grace_deadline")
@@ -405,6 +457,8 @@ def status_cmd(
         )
     elif status == "GRACE_PERIOD":
         con.print("\n[yellow]⚠ License in grace period. Renew before the grace window closes.[/yellow]")
+    else:
+        _status_hint(con, status)
 
     if status not in ("ACTIVE", "GRACE_PERIOD", "DEACTIVATED"):
         raise typer.Exit(1)
@@ -414,16 +468,31 @@ def status_cmd(
 # ravmem license renew
 # ---------------------------------------------------------------------------
 
+_KEY_OPTION_HELP = (
+    "License key to use. Only needed if the key was rotated in the console "
+    "(this server is then switched onto it), or if the server has no key on file."
+)
+
+
+def _run_recovery(con: Console, path: str, key: Optional[str], failed: str) -> dict:
+    client = _get_client()
+    body = {"license_key": key.strip()} if key and key.strip() else {}
+    try:
+        return _post_with_key_fallback(client, con, path, body)
+    except RavMemAPIError as exc:
+        _fail(con, failed, exc)
+
+
 @app.command("renew")
-def renew_cmd() -> None:
+def renew_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+) -> None:
     """Re-activate an expired license against the live license server."""
     con = _console()
-    client = _get_client()
     con.print("Renewing license…")
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/renew")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Renewal failed: {exc}[/red]")
+    result = _run_recovery(con, "/api/license/renew", key, "Renewal failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
     con.print(f"[green]Renewed. Status: {result.get('status')} | Expiry: {result.get('expiry_ts')}[/green]")
 
@@ -433,20 +502,19 @@ def renew_cmd() -> None:
 # ---------------------------------------------------------------------------
 
 @app.command("repair")
-def repair_cmd() -> None:
-    """Re-fetch and re-encrypt the JWT when the stored token is corrupted."""
+def repair_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt"),
+) -> None:
+    """Re-fetch a valid license token for this server (broken token, recreated
+    container, deactivated machine, or a key rotated in the console)."""
     con = _console()
-    con.print(
-        "[yellow]This will re-contact the license server using the stored key_hash "
-        "and machine fingerprint. RAVMEM_LICENSE_KEY must be set on the server.[/yellow]"
-    )
-    typer.confirm("Continue?", abort=True)
-
-    client = _get_client()
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/repair")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Repair failed: {exc}[/red]")
+    if not yes:
+        con.print("[yellow]This re-contacts the license server and replaces this server's stored token.[/yellow]")
+        typer.confirm("Continue?", abort=True)
+    result = _run_recovery(con, "/api/license/repair", key, "Repair failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
     con.print(f"[green]Repair complete. Status: {result.get('status')}[/green]")
 
@@ -489,29 +557,43 @@ def check_cmd() -> None:
     table.add_row("Revision", str(data.get("revision", "—")))
     table.add_row("Expires", _fmt_ts(data.get("expiry_ts")))
     table.add_row("Last heartbeat", _fmt_ts(data.get("last_heartbeat")))
+    if data.get("heartbeat_interval"):
+        table.add_row("Heartbeat every", f"{data['heartbeat_interval']}s (set in the license console)")
     grace_deadline = data.get("grace_deadline")
     if grace_deadline:
         table.add_row("[yellow]Grace deadline[/yellow]", f"[yellow]{_fmt_ts(grace_deadline)}[/yellow]")
     con.print(table)
+    _status_hint(con, status)
 
     if status not in ("ACTIVE", "GRACE_PERIOD", "DEACTIVATED", "SUSPENDED"):
         raise typer.Exit(1)
 
 
+def _status_hint(con: Console, status: str) -> None:
+    hints = {
+        "REVOKED": _license_hint("LICENSE_REVOKED"),
+        "REQUIRES_REACTIVATION": "Run: ravmem license repair   (or: ravmem license activate <key>)",
+        "TAMPERED": "Run: ravmem license repair",
+        "DEACTIVATED": "This machine was deactivated. To keep it, run: ravmem license activate <key>",
+        "SUSPENDED": _license_hint("SUBSCRIPTION_SUSPENDED"),
+        "UNINITIALIZED": "Run: ravmem license activate <key>",
+    }
+    if hints.get(status):
+        con.print(f"[yellow]-> {hints[status]}[/yellow]")
+
+
 @app.command("rebind")
-def rebind_cmd() -> None:
-    """Request a hardware fingerprint rebind after machine migration."""
+def rebind_cmd(
+    key: Optional[str] = typer.Option(None, "--key", help=_KEY_OPTION_HELP),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt"),
+) -> None:
+    """Move this license's seat onto this machine (after migration/recreate)."""
     con = _console()
-    con.print(
-        "[yellow]This submits a rebind request to the license server. "
-        "Vendor approval is required before a new token is issued.[/yellow]"
-    )
-    typer.confirm("Continue?", abort=True)
-
-    client = _get_client()
-    try:
-        result = _post_with_key_fallback(client, con, "/api/license/rebind")
-    except RavMemAPIError as exc:
-        con.print(f"[red]Rebind request failed: {exc}[/red]")
+    if not yes:
+        con.print("[yellow]This moves the license seat onto this machine's current identity.[/yellow]")
+        typer.confirm("Continue?", abort=True)
+    result = _run_recovery(con, "/api/license/rebind", key, "Rebind failed")
+    if result.get("status") == "rebind_pending":
+        con.print(f"[yellow]{result.get('message')}[/yellow]")
         raise typer.Exit(1)
-    con.print(f"[green]{result.get('message', 'Rebind request submitted.')}[/green]")
+    con.print(f"[green]{result.get('message', 'Rebound.')}[/green]")

{ravmem_cli-1.2.0 → ravmem_cli-1.3.0}/ravmem/cli/main.py

@@ -1,10 +1,20 @@
 """CLI entry point — registers all subcommands."""
 
 import logging
+import sys
 from typing import Optional
 
 import typer
 
+# Legacy Windows consoles (cp1252) can't encode the ⚠/…/— glyphs used in
+# output; without this, e.g. `ravmem license status` crashed with a
+# UnicodeEncodeError *after* printing, exiting non-zero on a healthy license.
+for _stream in (sys.stdout, sys.stderr):
+    try:
+        _stream.reconfigure(errors="replace")
+    except Exception:
+        pass
+
 
 def setup_logging(verbose: bool = False) -> None:
     """Configure root logger based on verbosity or RAVMEM_LOG_LEVEL env var.

{ravmem_cli-1.2.0 → ravmem_cli-1.3.0/ravmem_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.2.0
+Version: 1.3.0
 Summary: RavMem CLI — lightweight client for the RavMem code knowledge graph server
 Author-email: RavMem <harpreet.singh@ravmem.com>
 License-Expression: MIT