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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.1.1
+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
@@ -44,8 +44,10 @@ pip install ravmem-cli
 # Point the CLI at your RavMem server
 ravmem remote config --url http://localhost:7432 --api-key <ADMIN_TOKEN>
 
-# Activate the license (one command: seals the key to this machine, then
-# brings the server live — the key is never stored in a file)
+# Activate the license (one command: seals the key to the server's machine,
+# then brings the server live — the key is saved on the server's own data
+# volume so it survives restarts; it's never stored on the machine you run
+# this CLI command from)
 ravmem license activate RAVMEM-XXXX-XXXX-XXXX-XXXX
 
 # Register a repository

{ravmem_cli-1.1.1 → ravmem_cli-1.3.0}/README.md

@@ -14,8 +14,10 @@ pip install ravmem-cli
 # Point the CLI at your RavMem server
 ravmem remote config --url http://localhost:7432 --api-key <ADMIN_TOKEN>
 
-# Activate the license (one command: seals the key to this machine, then
-# brings the server live — the key is never stored in a file)
+# Activate the license (one command: seals the key to the server's machine,
+# then brings the server live — the key is saved on the server's own data
+# volume so it survives restarts; it's never stored on the machine you run
+# this CLI command from)
 ravmem license activate RAVMEM-XXXX-XXXX-XXXX-XXXX
 
 # Register a repository

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ravmem-cli"
-version = "1.1.1"
+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.1.1 → ravmem_cli-1.3.0}/ravmem/cli/license.py

@@ -39,6 +39,55 @@ def _get_client():
     return RavMemClient(base_url=cfg["server_url"], api_key=cfg.get("api_key") or None)
 
 
+def _post_with_key_fallback(client, con: Console, path: str, body: Optional[dict] = None) -> dict:
+    """POST to `path`; if the server has no license key on file, prompt for it
+    once and retry with it included in the body (the server persists it there,
+    so this shouldn't come up again on subsequent calls)."""
+    body = dict(body or {})
+    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 "") 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:
+                raise
+            body["license_key"] = key
+            return client.post(path, json=body)
+        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
 # ---------------------------------------------------------------------------
@@ -106,9 +155,11 @@ def activate_cmd(
 ) -> None:
     """One-step activation: seal the license to this machine and bring the server live.
 
-    The key is sent once, sealed to this machine (machine-bound), then discarded —
-    it is never stored in .env. Works whether the server is in activation-only mode
-    (first run) or already running.
+    The key is sent once and sealed to this machine (machine-bound). It's also
+    saved to the server's own data volume (not to its .env) so the license
+    survives restarts and container recreates without needing the key re-entered.
+    It is never stored on the machine you run this CLI command from. Works
+    whether the server is in activation-only mode (first run) or already running.
     """
     con = _console()
     if not key:
@@ -126,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:
@@ -161,17 +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:
+        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")
+        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)
+
+        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')}")
@@ -335,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")
@@ -358,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)
@@ -367,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 = client.post("/api/license/renew", json={})
-    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]")
 
@@ -386,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 = client.post("/api/license/repair", json={})
-    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]")
 
@@ -442,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 = client.post("/api/license/rebind", json={})
-    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.1.1 → 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.1.1 → ravmem_cli-1.3.0/ravmem_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.1.1
+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
@@ -44,8 +44,10 @@ pip install ravmem-cli
 # Point the CLI at your RavMem server
 ravmem remote config --url http://localhost:7432 --api-key <ADMIN_TOKEN>
 
-# Activate the license (one command: seals the key to this machine, then
-# brings the server live — the key is never stored in a file)
+# Activate the license (one command: seals the key to the server's machine,
+# then brings the server live — the key is saved on the server's own data
+# volume so it survives restarts; it's never stored on the machine you run
+# this CLI command from)
 ravmem license activate RAVMEM-XXXX-XXXX-XXXX-XXXX
 
 # Register a repository