cortexdb-cli 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

cortexdb_cli/__init__.py

@@ -1,3 +1,3 @@
 """CortexDB CLI - command-line interface for the v1 memory API."""
 
-__version__ = "0.7.0"
+__version__ = "0.7.1"

cortexdb_cli/commands/admin_access.py

@@ -151,7 +151,11 @@ def tenant_settings(ctx, root, mode, readiness_ticket, clear_readiness):
 def tenant_binding(ctx, root, from_tenant, apply_):
     """Bind a root's records and tombstones to the tenant it names (POST /v1/admin/access/tenant-binding).
 
-    A DRY RUN unless --apply; running it again is safe.
+    A DRY RUN unless --apply; running it again is safe. The dry run says how
+    the operator plane decides the real run (operator_plane: whether it
+    registers the root, is in-band, the tenant's mode): when it says
+    break_glass_required, pass --break-glass REASON --break-glass-ticket
+    TICKET with --apply.
     """
     cfg = ctx.obj
     scope = root_or_die(cfg, root)
@@ -169,6 +173,15 @@ def tenant_binding(ctx, root, from_tenant, apply_):
                       + (", root registered" if d.get("root_registered") else ""))
         if d.get("consistency_token"):
             console.print(f"[dim]  consistency token: {escape(str(d['consistency_token']))}[/dim]")
+        plane = d.get("operator_plane")
+        if isinstance(plane, dict):
+            # 0.14.1 (p6a C): how the operator plane decides the run.
+            console.print(f"  operator plane: mode {escape(str(plane.get('mode')))}"
+                          + (", the run registers the root" if plane.get("registers_root") else "")
+                          + (", an in-band path for the operator key" if plane.get("in_band") else ""))
+            if plane.get("break_glass_required"):
+                console.print("[warning]  The real run needs break-glass: add --break-glass REASON "
+                              "--break-glass-ticket TICKET to --apply (else 403 BREAK_GLASS_REQUIRED).[/warning]")
         if d.get("dry_run"):
             console.print("[dim]Nothing was changed. Run again with --apply.[/dim]")
 

cortexdb_cli/commands/changes.py

@@ -33,7 +33,15 @@ import click
 from cortexdb_cli.client import get_client, path_segment
 from cortexdb_cli.common import api_options, body_of, emit, read_json_file, root_or_die, send
 from cortexdb_cli.errors import handle_errors
-from cortexdb_cli.output import console, escape, is_json_mode
+from cortexdb_cli.output import console, err_console, escape, is_json_mode, print_json
+
+#: The exit status of a change-set command whose --wait ran out while the
+#: server still answered 202 (EX_TEMPFAIL): nothing failed, the evaluation
+#: goes on, and the same command sent again collects its answer.
+EXIT_STILL_EVALUATING = 75
+
+#: How long a change-set command keeps sending while the server answers 202.
+DEFAULT_WAIT_S = 120.0
 
 
 @click.group("changes")
@@ -41,6 +49,63 @@ def changes_group() -> None:
     """Access change sets - stage, preview, activate, discard."""
 
 
+def _wait_option(fn):
+    return click.option(
+        "--wait", "wait_s", type=click.FloatRange(min=0), default=DEFAULT_WAIT_S, show_default=True,
+        help="Seconds to keep sending the request while the server answers 202 (its evaluation runs "
+        "on); past it the command exits 75 and the same command collects the answer later.",
+    )(fn)
+
+
+def _evaluating(resp: Any) -> bool:
+    """A 202 that means the evaluation still runs (0.14.1): a preview's
+    `{state: "previewing"}`, a staging's or an activation's empty body. A
+    dated activation's 202 carries its status, and is its answer."""
+    if resp.status_code != 202:
+        return False
+    data = body_of(resp)
+    return not data or (isinstance(data, dict) and data.get("state") == "previewing")
+
+
+def _pause(resp: Any) -> float:
+    try:
+        seconds = float(resp.headers.get("retry-after") or 2)
+    except ValueError:
+        seconds = 2.0
+    return min(max(seconds, 0.5), 10.0)
+
+
+def send_until_evaluated(cfg: dict[str, Any], label: str, call, wait_s: float) -> tuple[Any, float | None]:
+    """Send `call` until the server answers anything but an evaluation's
+    202. The same request sent again joins the evaluation, or once it ended
+    is answered by it. Returns the response and, when --wait ran out first,
+    the seconds waited (else None)."""
+    start = time.monotonic()
+    while True:
+        resp = send(cfg, label, call)
+        if not _evaluating(resp):
+            return resp, None
+        waited = time.monotonic() - start
+        pause = _pause(resp)
+        if waited + pause > wait_s:
+            return resp, waited
+        if not is_json_mode(cfg):
+            err_console.print(f"[dim]  still evaluating after {waited:.0f} s (202); asking again in "
+                              f"{pause:.0f} s[/dim]")
+        time.sleep(pause)
+
+
+def still_evaluating(cfg: dict[str, Any], change_id: str, what: str, waited: float, again: str):
+    """--wait ran out on a 202: say so (never as an error) and exit 75."""
+    if is_json_mode(cfg):
+        print_json({"id": change_id, "state": "evaluating", "request": what, "waited_s": round(waited),
+                    "again": again})
+    else:
+        console.print(f"[warning]The server is still evaluating the {what} of {escape(change_id)} after "
+                      f"{waited:.0f} s; it goes on. {escape(again)}[/warning]")
+    raise SystemExit(EXIT_STILL_EVALUATING)
+
+
 def _scope_option(fn):
     return click.option(
         "--scope", "-S", default=None,
@@ -239,11 +304,12 @@ def _params(proposer: str | None, scope: str | None = None) -> dict[str, str] |
 @click.option("--convert", is_flag=True, help="A version-1 tree conversion: its preview must change no access.")
 @click.option("--resync", is_flag=True, help="A source's resync change set (served during a restore).")
 @click.option("--resync-last", is_flag=True, help="The last resync change set of the restore.")
+@_wait_option
 @api_options
 @click.pass_context
 @handle_errors
 def changes_stage(ctx, change_id, file, part, deletes, scope, parts_total, activate_at, reason,
-                  narrowing, convert, resync, resync_last):
+                  narrowing, convert, resync, resync_last, wait_s):
     """Stage a change set's first parts under your own id (POST /v1/access/changes).
 
     \b
@@ -251,7 +317,9 @@ def changes_stage(ctx, change_id, file, part, deletes, scope, parts_total, activ
         cortexdb changes stage drop-tmp --delete org:acme/team:tmp --narrowing
 
     Staging is idempotent by id: the same parts sent again answer the
-    change set's status.
+    change set's status. A narrowing or a conversion staging whose check
+    runs long answers 202 and goes on; the CLI sends it again until it
+    answers (--wait).
     """
     cfg = ctx.obj
     doc = read_json_file(file, "--file") if file else None
@@ -277,8 +345,12 @@ def changes_stage(ctx, change_id, file, part, deletes, scope, parts_total, activ
     if resync or resync_last:
         body["resync"] = {"last": bool(resync_last)}
     with get_client(cfg) as client:
-        data = body_of(send(cfg, "Staging...", lambda: client.post("/v1/access/changes", json=body)))
-    emit(cfg, data, _render_state)
+        resp, waited = send_until_evaluated(cfg, "Staging...",
+                                            lambda: client.post("/v1/access/changes", json=body), wait_s)
+    if waited is not None:
+        still_evaluating(cfg, change_id, "staging", waited,
+                         "Send the same `cortexdb changes stage` again for its status, or `cortexdb changes get` it.")
+    emit(cfg, body_of(resp), _render_state)
 
 
 @changes_group.command("parts")
@@ -286,24 +358,33 @@ def changes_stage(ctx, change_id, file, part, deletes, scope, parts_total, activ
 @_records_options
 @_scope_option
 @_proposer_option
+@_wait_option
 @api_options
 @click.pass_context
 @handle_errors
-def changes_parts(ctx, change_id, file, part, deletes, scope, proposer):
-    """Stage more parts of a change set (POST /v1/access/changes/{id}/parts)."""
+def changes_parts(ctx, change_id, file, part, deletes, scope, proposer, wait_s):
+    """Stage more parts of a change set (POST /v1/access/changes/{id}/parts).
+
+    A part whose check runs long answers 202 and goes on; the CLI sends it
+    again until it answers (--wait).
+    """
     cfg = ctx.obj
     doc = read_json_file(file, "--file") if file else None
     body = {"scope": root_or_die(cfg, scope), "parts": build_parts(doc, part, deletes, default_part=None)}
     with get_client(cfg) as client:
-        data = body_of(send(cfg, "Staging parts...",
-                            lambda: client.post(_id_path(change_id, "/parts"), json=body,
-                                                params=_params(proposer))))
-    emit(cfg, data, _render_state)
+        resp, waited = send_until_evaluated(
+            cfg, "Staging parts...",
+            lambda: client.post(_id_path(change_id, "/parts"), json=body, params=_params(proposer)), wait_s)
+    if waited is not None:
+        still_evaluating(cfg, change_id, "staging of its parts", waited,
+                         "Send the same `cortexdb changes parts` again for its status, or `cortexdb changes get` it.")
+    emit(cfg, body_of(resp), _render_state)
 
 
 def preview_change_set(cfg, client, change_id, root, proposer=None, people=False, limit=None,
-                       cursor=None, wait_s=60.0):
-    """POST .../preview, retrying while the server answers 202 (being computed)."""
+                       cursor=None, wait_s=DEFAULT_WAIT_S):
+    """POST .../preview, sent again while the server answers 202
+    `{state: "previewing"}`; exits 75 when --wait runs out first."""
     body: dict[str, Any] = {"scope": root}
     if people:
         body["people"] = True
@@ -311,17 +392,13 @@ def preview_change_set(cfg, client, change_id, root, proposer=None, people=False
         body["limit"] = limit
     if cursor:
         body["cursor"] = cursor
-    deadline = time.monotonic() + wait_s
-    while True:
-        resp = send(cfg, "Previewing...",
-                    lambda: client.post(_id_path(change_id, "/preview"), json=body, params=_params(proposer)))
-        if resp.status_code != 202 or time.monotonic() >= deadline:
-            return body_of(resp)
-        try:
-            pause = float(resp.headers.get("retry-after") or 1)
-        except ValueError:
-            pause = 1.0
-        time.sleep(min(max(pause, 0.2), 5.0))
+    resp, waited = send_until_evaluated(
+        cfg, "Previewing...",
+        lambda: client.post(_id_path(change_id, "/preview"), json=body, params=_params(proposer)), wait_s)
+    if waited is not None:
+        still_evaluating(cfg, change_id, "preview", waited,
+                         "Run the same `cortexdb changes preview` again to collect it.")
+    return body_of(resp)
 
 
 @changes_group.command("preview")
@@ -331,8 +408,7 @@ def preview_change_set(cfg, client, change_id, root, proposer=None, people=False
 @click.option("--people", is_flag=True, help="List each person who gains or loses access, per unit.")
 @click.option("--limit", type=click.IntRange(min=1), default=None, help="Units per page.")
 @click.option("--cursor", default=None, help="The next_cursor of a previous page.")
-@click.option("--wait", "wait_s", type=float, default=60.0, show_default=True,
-              help="Seconds to keep asking while the preview is being computed (202).")
+@_wait_option
 @api_options
 @click.pass_context
 @handle_errors
@@ -340,7 +416,9 @@ def changes_preview(ctx, change_id, scope, proposer, people, limit, cursor, wait
     """A change set's access diff and its sha256 structural hash (POST .../{id}/preview).
 
     A page holds at most 1 MiB: a unit that does not fit continues on the
-    next page (--cursor), and its counts on this page are marked +.
+    next page (--cursor), and its counts on this page are marked +. While
+    the evaluation runs past the server's wait it answers 202
+    {state: previewing}; the CLI asks again until it answers (--wait).
     """
     cfg = ctx.obj
     with get_client(cfg) as client:
@@ -356,16 +434,20 @@ def changes_preview(ctx, change_id, scope, proposer, people, limit, cursor, wait
 @click.option("--preview-hash", metavar="HASH",
               help="The approved preview's hash (sha256:...). Without it the CLI previews first.")
 @click.option("--yes", "-y", is_flag=True, help="Skip the confirmation after the preview.")
+@_wait_option
 @api_options
 @click.pass_context
 @handle_errors
-def changes_activate(ctx, change_id, scope, proposer, preview_hash, yes):
+def changes_activate(ctx, change_id, scope, proposer, preview_hash, yes, wait_s):
     """Approve and activate a change set (POST /v1/access/changes/{id}/activate).
 
     Without --preview-hash the CLI previews it, shows the diff, asks (on a
     terminal, unless --yes), and activates with that preview's hash. A dated
-    change set (--activate-at) answers 202: the approval is recorded for its
-    date.
+    change set (--activate-at) answers 202 with its status: the approval is
+    recorded for its date. An activation whose checks run long answers 202
+    with no body and goes on in the background; the CLI sends it again until
+    it answers its status (--wait), and each wait (the preview's, then the
+    activation's) has the whole of --wait.
 
     With the operator key, a change set whose preview says in_band (it
     registers a scope, adds a service: principal, or adds or widens a
@@ -378,7 +460,7 @@ def changes_activate(ctx, change_id, scope, proposer, preview_hash, yes):
     root = root_or_die(cfg, scope)
     with get_client(cfg) as client:
         if not preview_hash:
-            preview = preview_change_set(cfg, client, change_id, root, proposer)
+            preview = preview_change_set(cfg, client, change_id, root, proposer, wait_s=wait_s)
             preview_hash = preview.get("preview_hash")
             if not preview_hash:
                 raise click.UsageError("the preview returned no preview_hash; pass --preview-hash")
@@ -390,10 +472,14 @@ def changes_activate(ctx, change_id, scope, proposer, preview_hash, yes):
                 if not yes:
                     click.confirm(f"Activate change set {change_id}?", abort=True)
         body = {"scope": root, "preview_hash": preview_hash}
-        resp = send(cfg, "Activating...",
-                    lambda: client.post(_id_path(change_id, "/activate"), json=body, params=_params(proposer)))
-        data = body_of(resp)
-    emit(cfg, data, _render_state)
+        resp, waited = send_until_evaluated(
+            cfg, "Activating...",
+            lambda: client.post(_id_path(change_id, "/activate"), json=body, params=_params(proposer)), wait_s)
+    if waited is not None:
+        still_evaluating(cfg, change_id, "activation", waited,
+                         "Its activation goes on in the background: `cortexdb changes get` shows its state, and "
+                         "the same `cortexdb changes activate --preview-hash` again answers its status.")
+    emit(cfg, body_of(resp), _render_state)
 
 
 @changes_group.command("get")

cortexdb_cli/commands/tokens.py

@@ -21,8 +21,10 @@ no `--scope`) or its `--confine` / `--exact` entries, all in that one root
 the trusted operator's alone, for a `service:` or `system:` subject (else
 403 `deployment_mint_requires_operator`). A minted token holds no more than
 its minter: its caps and entries lie within the minting token's own.
-Lifetimes are capped by the subject's ceiling (7 days for a person or an
-agent, 30 for a service): above it the mint is 422 `ttl_too_long`.
+Lifetimes are capped by the subject's ceiling, the server's settings since
+0.14.1 (`CORTEX_MINT_MAX_LIFETIME_*`; by default 90 days for a person, 7 for
+an agent, 30 for a service, 24 hours with a chain claim): above it the mint
+is 422 `ttl_too_long`, naming the ceiling (`details.ceiling_s`).
 """
 
 from __future__ import annotations

cortexdb_cli/errors.py

@@ -171,9 +171,13 @@ def _reason_hints(err: ApiError) -> str | None:
         if reason == "invalid":
             return f"--cap {entry} is no capability name; see `cortexdb policy effective` for the names."
     table = {
+        # The ceilings are the server's settings since 0.14.1
+        # (CORTEX_MINT_MAX_LIFETIME_*); details.ceiling_s is the one applied.
         "ttl_too_long": lambda: (
-            f"Mint a shorter token: --ttl at most {_d(err, 'ceiling_s')} s "
-            "(7 days for a person or an agent, 30 for a service, 24 h with chain claims)."
+            (f"Mint a shorter token: --ttl at most {_d(err, 'ceiling_s')} s, this subject's ceiling"
+             if _d(err, "ceiling_s") else "Mint a shorter token: --ttl within this subject's ceiling")
+            + " (by default 90 days for a person, 7 for an agent, 30 for a service, 24 h with chain claims; "
+            "the server's CORTEX_MINT_MAX_LIFETIME_* settings)."
         ),
         "ttl_out_of_range": lambda: "--ttl is past what a timestamp holds; pick a sane lifetime.",
         "lifetime_over_ceiling": lambda: (
@@ -475,6 +479,19 @@ def hint_for(err: ApiError) -> str | None:  # noqa: C901 - one table
             "app_unknown": "The token's application has no record (`cortexdb apps put`).",
             "not_combinable": "--mounts does not combine with subtree, cohort or recency order.",
         }.get(reason, None)
+    if code in ("INVALID_ACCESS_RECORD", "INVALID_SCOPE_TREE") and reason == "version_downgrade":
+        # 0.14.1 (p6a E): a put that leaves out every version-2 field of a
+        # stored version-2 record would make it version 1; only `convert`
+        # says that is meant, and a legacy route has none.
+        path = _d(err, "path") or "the record"
+        dropped = _list(_d(err, "dropped") or [], limit=8) or "its version-2 fields"
+        how = (
+            "or, if the conversion is meant, stage the change set with --convert (it may change no access)"
+            if code == "INVALID_ACCESS_RECORD"
+            else "or make the change with a change set staged with --convert (a legacy route has no convert)"
+        )
+        return (f"{path} is a version-2 record and this write leaves out {dropped}, which would make it "
+                f"version 1: state them in the record, {how}.")
     if code == "INVALID_ACCESS_RECORD":
         path = _d(err, "path")
         return f"A record is out of shape{f' at {path}' if path else ''} ({reason or 'see the message'})."

{cortexdb_cli-0.7.0.dist-info → cortexdb_cli-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cortexdb-cli
-Version: 0.7.0
+Version: 0.7.1
 Summary: Command-line interface for CortexDB — the long-term memory layer for AI.
 Project-URL: Homepage, https://cortexdb.ai
 Project-URL: Documentation, https://cortexdb.ai/docs
@@ -36,8 +36,8 @@ Command-line interface for [CortexDB](https://cortexdb.ai) — the long-term mem
 
 Wraps the v1 HTTP API in a small, fast Click + Rich CLI. Anonymous signup
 in one command, no email or card; works against the public SaaS or any
-self-hosted CortexDB deployment. Version 0.7.0 covers CortexDB 0.14.0,
-shared memory included: the access API, change sets, the directory,
+self-hosted CortexDB deployment. Version 0.7.1 covers CortexDB 0.14.1 and
+0.14.0, shared memory included: the access API, change sets, the directory,
 applications, rollups, publishing and the new erasures.
 
 ## Install
@@ -81,6 +81,20 @@ When a token expires you have two safe options:
 For a second brain alongside the first, isolate instead of replacing:
 `cortexdb --config-dir <dir> init`, or set `CORTEXDB_HOME`.
 
+## What's new for CortexDB 0.14.1 (cortexdb-cli 0.7.1)
+
+- **Change sets that take long.** A staging, a preview or an activation whose
+  evaluation runs past the server's wait answers 202 and goes on. `changes
+  stage`, `parts`, `preview` and `activate` send the request again until it
+  answers, with a progress line, for `--wait` seconds (120 by default); past
+  it they exit 75 and say how to collect the answer. A 202 is never an error.
+- **The tenant-binding dry run** shows how the operator plane will decide the
+  real run, and says when `--apply` needs `--break-glass`.
+- **A write that would make a version-2 record version 1** is refused; the
+  hint names the fields it drops and `--convert`.
+- **Token lifetimes** are the server's settings: by default 90 days for a
+  person, 7 for an agent, 30 for a service, 24 hours with a chain claim.
+
 ## What's new for CortexDB 0.14.0 (cortexdb-cli 0.7.0)
 
 CortexDB 0.14.0 is the breaking release of shared memory. What changes for a
@@ -112,9 +126,9 @@ CLI user:
   compartment gets the server's default (granular there) instead of 422
   `VIEW_NOT_ALLOWED_AT_SCOPE`.
 - **Tokens.** A token that carries `scopes` holds only the families its
-  entries name, lifetimes are capped (7 days for a person or an agent, 30 for
-  a service, 24 hours with chain claims), and `act` must name a delegable
-  agent. Every mint names its tenant root (`--scope`, `--tenant` or its
+  entries name, lifetimes are capped (the server's settings since 0.14.1: by
+  default 90 days for a person, 7 for an agent, 30 for a service, 24 hours
+  with chain claims), and `act` must name a delegable agent. Every mint names its tenant root (`--scope`, `--tenant` or its
   `--confine` entries); only the operator mints deployment-wide, for a
   service. A minted token holds no more than its minter. `cortexdb tokens
   mint` mints with every field: `--confine`, `--exact` (the `CAP:PATH!`
@@ -241,6 +255,9 @@ cortexdb changes discard org-compile
 `--file` holds a list of records (each a put), operations
 (`{"path", "op": "put" | "delete", "record"}`), `{"records": [...]}` or
 `{"parts": [...]}`; `--delete PATH` adds deletes; `changes parts` stages more.
+A staging, a preview or an activation whose evaluation runs long answers 202
+(0.14.1): the command sends it again until it answers, for `--wait` seconds
+(120 by default), then exits 75 saying how to collect the answer.
 
 ### watch and notices
 

{cortexdb_cli-0.7.0.dist-info → cortexdb_cli-0.7.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-cortexdb_cli/__init__.py,sha256=63v54GP3KNOkRT09aXp0_Ol7Ch5Vc20Lmk2pooBHils,90
+cortexdb_cli/__init__.py,sha256=VkuIG9ak4LficJ5PaL_-FwK1yH9wnAlmdwaYYIAbhw4,90
 cortexdb_cli/client.py,sha256=qxETsZzcSxx1NS7sG3M1a48i46ykZRZdjcbBf2wjGWA,6894
 cortexdb_cli/common.py,sha256=1iCsiLYPDXi4ZbIGo_Nbg5xteL4_KbHC0Z--211uxac,11377
 cortexdb_cli/config.py,sha256=ee1qmOfqMwilL81ujaqjf6TjjlrFG7WZAHRIgeyif9U,5690
-cortexdb_cli/errors.py,sha256=LpQ-8GmMTx3KzB49CFRr84ZrTZ2cXr5uMcP6Uo6vksw,33000
+cortexdb_cli/errors.py,sha256=63i9dB3FvkWtb6z75nOB80ApcjeGfIQwMKA51bDIQgM,34250
 cortexdb_cli/harness_packs_data.py,sha256=38oyPX47a_S3BRgiNxml37auhIUyWafeJ_MtApX9tWE,10693
 cortexdb_cli/main.py,sha256=-ohG6a90vlVfTX8G9VdfitjWoHbK1WgETHKiLCEa_qw,12567
 cortexdb_cli/onboarding.py,sha256=kjCxhMOY2nReNyEfGGGsmHO6_j4CXS5o2LIwzpFzIok,17527
@@ -11,13 +11,13 @@ cortexdb_cli/state.py,sha256=pfslyJ9xuZno4n13-maJ0qKmD7nxWkFznjrVvItYK4I,1527
 cortexdb_cli/commands/__init__.py,sha256=Uqz-6IAeIxrSS94FHI6Q0iqDf_2MQeHKY0LaHgEC4HU,36
 cortexdb_cli/commands/access.py,sha256=-Ex3JM5cpz3k5GLxnTstRlKWGsUZB9HRHqMZviiUjMY,36296
 cortexdb_cli/commands/admin.py,sha256=Cf_Ay-duZehY2tFxHlJ4qRlAeIpQkhf0lNTZx7WcJjc,24104
-cortexdb_cli/commands/admin_access.py,sha256=FjtXb4OtArgNl65OT0aMw4TcMzUvQk0idt4fhXIUqTc,11741
+cortexdb_cli/commands/admin_access.py,sha256=1cEZszPy9QFOsJLZq0f-BROMi4maPJGNDzbHKz7PiTw,12702
 cortexdb_cli/commands/answer.py,sha256=0qWWCTEdnDG4Od4nzAGKi9DBE7rmxuVHQLv9uzW2p5I,3674
 cortexdb_cli/commands/apps.py,sha256=_aqeDlb-cTF3exVewm-x2QJOzTDke_Mw-idvqBCXJTc,6299
 cortexdb_cli/commands/audit.py,sha256=_zfAQZQm7hjFr-Ot3CtzCryE6VqO7pChHbGFREQ5BC4,2690
 cortexdb_cli/commands/auth.py,sha256=5iPfUNOMnVGe-ST9FRFi65Z4Qoys35xQeGlvoYBxPCo,4193
 cortexdb_cli/commands/beliefs.py,sha256=CRioAHyQl68xnx5TjiyKGTrrMiax_BhNYcJGq7Gye1A,8519
-cortexdb_cli/commands/changes.py,sha256=sZXS-kX1XiGSRSoPJOCL1YqjeuYbN7Gz_YpnYYnFQZM,19607
+cortexdb_cli/commands/changes.py,sha256=eBZAq6BzD9lTB8avgVLDGdutppRkWdTcFBErt7mu1Rc,23742
 cortexdb_cli/commands/claims.py,sha256=4RWhWLe1uGLTRy7Ffe3rTwGTzudLwGmInu-OCGcEYO4,3777
 cortexdb_cli/commands/code.py,sha256=gR3hdB1eg5qA1apbwXkXAAyaPJo2Uy0E6AlrufTpClI,10906
 cortexdb_cli/commands/compose.py,sha256=TJwDuxmVuwn0y3X4YN1wXq6xKnGzVWSRKBmMGdL_nCU,4192
@@ -41,11 +41,11 @@ cortexdb_cli/commands/recall.py,sha256=B-8s4Y9OybU0R445mh-mcBYYdkYofiBJakdp3kDU6
 cortexdb_cli/commands/rollups.py,sha256=wveVXfZHTFzvCyOYvM0REL2sjUsTQDVUinwgAJR-uPc,6419
 cortexdb_cli/commands/scopes.py,sha256=EssL4g0hNQfS6GpU8ZZeHDWtYeoC6wUW2naSknisdIE,5286
 cortexdb_cli/commands/search.py,sha256=ntKzgEuAEJtDsw_4tS3cP6y_ycRP_RzMoyuMXRvXOao,2709
-cortexdb_cli/commands/tokens.py,sha256=RsS-zMm1lfaWxgPF9SkHeOFxgJV9ISnI5-Q3aUJ3q7A,8152
+cortexdb_cli/commands/tokens.py,sha256=wvbKRnsS3ACUnpdgm16G2BJ31uPI5Fxbu23Zuc_4LJY,8305
 cortexdb_cli/commands/understanding.py,sha256=5sDus9F5xcZhtuqUAeTQIc6z6hfBTbIYyQG-c4nx5rA,6003
 cortexdb_cli/commands/watch.py,sha256=o4o1NmYKgoDu2b-KXToziQ9tXzbShs4PU2kwUFYFwBs,10749
 cortexdb_cli/commands/wire.py,sha256=M3UUHScmvr_MDrX_RaMBg-YLTcHKUq9woNkT4KHJKfs,8131
-cortexdb_cli-0.7.0.dist-info/METADATA,sha256=Wv1f_tJ_-xf5V3Xz5g6csGAOyacfBHAaHChBSBYv-qw,17137
-cortexdb_cli-0.7.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-cortexdb_cli-0.7.0.dist-info/entry_points.txt,sha256=h3sEbdqqvtv8LBbRLUgybYPo9N2lpU85fQUSh5ToEvs,51
-cortexdb_cli-0.7.0.dist-info/RECORD,,
+cortexdb_cli-0.7.1.dist-info/METADATA,sha256=3FE4vYfjXAD49ub_lK3rg8tLwnqTdT4tuN3eKvbZR7U,18269
+cortexdb_cli-0.7.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+cortexdb_cli-0.7.1.dist-info/entry_points.txt,sha256=h3sEbdqqvtv8LBbRLUgybYPo9N2lpU85fQUSh5ToEvs,51
+cortexdb_cli-0.7.1.dist-info/RECORD,,