memorysync-cli 1.1.1__tar.gz → 1.1.2__tar.gz

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.1.1
+Version: 1.1.2
 Summary: MemorySync from your terminal. Zero dependencies.
 Project-URL: Documentation, https://docs.memorysync.io/cli
 Project-URL: Homepage, https://memorysync.io/cli

memorysync_cli-1.1.2/src/memorysync_cli/_version.py

@@ -0,0 +1 @@
+__version__ = "1.1.2"

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/args.py

@@ -27,29 +27,40 @@ from __future__ import annotations
 
 from typing import Any
 
+from . import registry
 from .errors import usage_error
 
-# Flags that take a value. Everything else is boolean. Kept in step with the
-# Node CLI's VALUED set; the parity test asserts every registry flag is known
-# here, so a flag added there cannot go unhandled.
-VALUED = {
-    "profile",
-    "api-key",
-    "base-url",
-    "user",
-    "project",
-    "output",
-    "timeout",
-    "metadata",
-    "file",
-    "source",
-    "limit",
-    "importance",
-    "batch-size",
-    "out",
-    "format",
-    "query",
-}
+
+def _collect_valued() -> set[str]:
+    """Flags that take a value. Everything else is boolean.
+
+    Derived from the shared registry rather than hand-listed, matching
+    ``sdk/cli/src/args.mjs``. The registry already marks a value-taking flag with
+    ``value``, and keeping a second copy of that fact here meant the two could
+    disagree - which they did: ``--email``, ``--code``, ``--password`` and
+    ``--agent-caller`` were declared with a ``value`` but missing from the set, so
+    ``--email you@example.com`` parsed as ``{"email": True}`` and sent the string
+    "true" to the API. ``--password`` was worse: the account password became
+    "true" and the real one was left in shell history as a positional.
+
+    A flag is valued if any declaration of it says so, including on a subcommand.
+    """
+    valued: set[str] = set()
+
+    def visit(flags: list[dict[str, Any]] | None) -> None:
+        for flag in flags or []:
+            if flag.get("value"):
+                valued.add(flag["name"].lstrip("-"))
+
+    visit(registry.global_flags())
+    for spec in registry.commands().values():
+        visit(spec.get("flags"))
+        for sub in spec.get("subcommands", []):
+            visit(sub.get("flags"))
+    return valued
+
+
+VALUED = _collect_valued()
 
 SHORT = {
     "p": "profile",

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/commands/admin.py

@@ -10,11 +10,14 @@ someone spends an afternoon debugging an empty search.
 
 from __future__ import annotations
 
+import json
+import math
 import os
 import platform
 import sys
 import time
-from typing import Any
+from datetime import datetime, timezone
+from typing import Any, Mapping
 
 from .. import config as config_module
 from .. import credentials
@@ -30,27 +33,94 @@ from ..output import render_table, style
 #: ``api_key`` is deliberately absent. Keys go to the keychain through ``init``, and
 #: accepting one here would write a credential into a file people paste into bug
 #: reports.
-_SETTABLE = frozenset({"user", "project", "base_url", "output", "timeout"})
+#: Declaration order, for the error message. A frozenset has no order, and
+#: sorting it put the keys in a different order from the Node CLI's message.
+_SETTABLE_ORDER = ("user", "project", "base_url", "output", "timeout")
+_SETTABLE = frozenset(_SETTABLE_ORDER)
 
 
-def _percent(used: Any, limit: Any) -> str:
-    if not isinstance(used, (int, float)) or not isinstance(limit, (int, float)) or limit <= 0:
-        return "-"
-    return f"{min(100, round(used / limit * 100))}%"
+def _quota_rows(usage: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Per-metric usage with a percentage. Mirrors the Node CLI's ``quotaRows``.
+
+    ``percent`` is a number rounded to one decimal, not a preformatted string. It
+    used to be ``"1%"`` here and ``0.5`` in the Node CLI, so an agent reading
+    ``--json`` from the two got different types for the same field.
+    """
+    rows = []
+    for entry in usage.get("metrics") or []:
+        if not isinstance(entry, dict):
+            continue
+        limit = entry.get("limit")
+        used = entry.get("used")
+        if isinstance(limit, (int, float)) and limit and isinstance(used, (int, float)):
+            percent = min(100, round(used / limit * 1000) / 10)
+            # Match JavaScript, where 0.5 prints as "0.5" and 12.0 prints as "12".
+            if percent == int(percent):
+                percent = int(percent)
+        else:
+            limit = None
+            percent = 0
+        rows.append(
+            {
+                "metric": entry.get("metric"),
+                "label": entry.get("label"),
+                "used": used,
+                "limit": limit,
+                "percent": percent,
+            }
+        )
+    return rows
 
 
-def _evaluation_usage_summary(api: Any) -> dict:
+def _bar(percent: float, width: int = 24) -> str:
+    """The usage bar, identical to the Node CLI's ``bar``.
+
+    Green under 80%, yellow from 80, red at 100. The filled portion is coloured and
+    the remainder dimmed, so the shape reads the same without colour.
+    """
+    filled = max(0, min(width, round(percent / 100 * width)))
+    if percent >= 100:
+        painter = style.red
+    elif percent >= 80:
+        painter = style.yellow
+    else:
+        painter = style.green
+    return painter("\u2588" * filled) + style.dim("\u2591" * (width - filled))
+
+
+def _days_until(iso: Any) -> int | None:
+    """Whole days from now until *iso*, or ``None`` when it cannot be read."""
+    if not iso:
+        return None
+    try:
+        text = str(iso).replace("Z", "+00:00")
+        end = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    if end.tzinfo is None:
+        end = end.replace(tzinfo=timezone.utc)
+    seconds = (end - datetime.now(timezone.utc)).total_seconds()
+    return max(0, math.ceil(seconds / 86400))
+
+
+def _evaluation_usage_summary(api: Any) -> tuple[dict, dict]:
     """Reshape ``/evaluation/usage`` into what ``quota`` already renders.
 
     Same keys the billing summary returns, so the renderer and ``--json`` consumers
     do not have to care which kind of key they are looking at. Mirrors the Node
-    CLI's ``evaluationQuota``.
+    CLI's ``evaluationQuota``, including the cycle fields this used to drop - so
+    ``days_until_reset`` and ``resets_at`` came back null under this CLI and
+    populated under the Node one.
     """
     usage = api.evaluation_usage() or {}
     add = usage.get("add_requests") or {}
     retrieval = usage.get("retrieval_requests") or {}
-    return {
+    cycle_start = usage.get("cycle_start")
+    summary = {
         "plan_id": usage.get("plan"),
+        "billing_period": str(cycle_start)[:7] if cycle_start else None,
+        "current_period_end": usage.get("cycle_end"),
+        "days_until_reset": _days_until(usage.get("cycle_end")),
         "metrics": [
             {
                 "metric": "add_requests",
@@ -65,10 +135,13 @@ def _evaluation_usage_summary(api: Any) -> dict:
                 "limit": retrieval.get("limit"),
             },
         ],
+    }
+    extra = {
         "claimed": usage.get("claimed") is True,
         "expires_at": usage.get("expires_at"),
         "claim_command": usage.get("claim_command"),
     }
+    return summary, extra
 
 
 def quota(ctx: dict) -> dict:
@@ -79,72 +152,75 @@ def quota(ctx: dict) -> dict:
     """
     api = ctx["api"]
 
+    extra: dict[str, Any] = {}
     if is_evaluation_key(ctx.get("api_key")):
         # ``/org/billing/usage-summary`` needs the ``billing.view`` capability and
         # the ``billing:read`` scope, and an evaluation key is granted neither on
         # purpose: ``billing:read`` also opens ``GET /org/billing/profit``, which
         # returns cost and margin from our internal pricing model. The server
         # exposes the same counters without the priced fields, so route there.
-        summary = _evaluation_usage_summary(api)
+        summary, extra = _evaluation_usage_summary(api)
     else:
         summary = api.usage_summary() or {}
 
-    metrics = [m for m in (summary.get("metrics") or []) if isinstance(m, dict)]
-
-    rows = [
-        {
-            "metric": entry.get("metric"),
-            "used": entry.get("used"),
-            "limit": entry.get("limit"),
-            "remaining": (
-                entry["limit"] - entry["used"]
-                if isinstance(entry.get("limit"), (int, float))
-                and isinstance(entry.get("used"), (int, float))
-                else None
-            ),
-            "percent": _percent(entry.get("used"), entry.get("limit")),
-        }
-        for entry in metrics
-    ]
+    rows = _quota_rows(summary)
+    data = {
+        "billing_period": summary.get("billing_period"),
+        "plan_id": summary.get("plan_id"),
+        "days_until_reset": summary.get("days_until_reset"),
+        "resets_at": summary.get("current_period_end"),
+        "metrics": rows,
+        **extra,
+    }
 
     def render() -> str:
-        if not rows:
-            return style.dim("No usage reported for this billing cycle.")
-        table = render_table(
-            ["metric", "used", "limit", "remaining", "used %"],
-            [
-                [
-                    row["metric"],
-                    row["used"],
-                    "unlimited" if row["limit"] in (None, 0) else row["limit"],
-                    "-" if row["remaining"] is None else row["remaining"],
-                    row["percent"],
-                ]
-                for row in rows
-            ],
-        )
-        # An evaluation allowance does not reset on a cycle: the key stops working
-        # at expiry, so that is the date worth printing. Matches the Node CLI.
-        expiry_note = ""
-        if summary.get("expires_at") and not summary.get("claimed"):
-            expiry_note = "\n" + style.yellow(
-                "Unclaimed evaluation key, expires "
-                f"{str(summary['expires_at'])[:10]}."
+        lines = [
+            f"{style.bold('Plan')} {summary.get('plan_id')}   "
+            f"{style.dim('period ' + str(summary.get('billing_period')))}",
+            "",
+        ]
+        for row in rows:
+            limit = "unlimited" if row["limit"] is None else f"{row['limit']:,}"
+            suffix = "" if row["limit"] is None else f"  {row['percent']}%"
+            label = str(row["label"] or "").ljust(20)
+            lines.append(
+                f"{label} {_bar(row['percent'])}  {str(row['used']).rjust(7)} / {limit}{suffix}"
             )
 
-        exhausted = [r["metric"] for r in rows if r["remaining"] == 0]
+        exhausted = [
+            r for r in rows if r["limit"] is not None and (r["used"] or 0) >= r["limit"]
+        ]
+        near = [
+            r
+            for r in rows
+            if r["limit"] is not None and r["percent"] >= 80 and (r["used"] or 0) < r["limit"]
+        ]
+        lines.append("")
         if exhausted:
-            warning = style.yellow(
-                "At the limit: " + ", ".join(str(m) for m in exhausted) + "."
+            lines.append(
+                style.red(
+                    " and ".join(str(r["label"]) for r in exhausted)
+                    + " exhausted. Calls now return empty results instead of errors, "
+                    "so nothing is being stored or retrieved."
+                )
+            )
+        elif near:
+            lines.append(
+                style.yellow(" and ".join(str(r["label"]) for r in near) + " above 80%.")
             )
-            note = style.dim(
-                "Writes and reads return empty rather than failing, so check here "
-                "before assuming memory is missing."
+        if summary.get("days_until_reset") is not None:
+            lines.append(style.dim(f"Resets in {summary['days_until_reset']} day(s)."))
+        if extra and not extra.get("claimed") and extra.get("expires_at"):
+            # An evaluation allowance does not reset on the cycle: the key stops
+            # working at expiry, so the date that matters is that one.
+            lines.append(
+                style.yellow(
+                    f"Unclaimed evaluation key, expires {str(extra['expires_at'])[:10]}."
+                )
             )
-            return f"{table}\n\n{warning}\n{note}{expiry_note}"
-        return f"{table}{expiry_note}"
+        return "\n".join(lines)
 
-    return {"data": rows, "text": render}
+    return {"data": data, "text": render}
 
 
 def status(ctx: dict) -> dict:
@@ -372,14 +448,16 @@ def config_command(ctx: dict) -> dict:
         data = config_module.redacted()
         return {
             "data": data,
+            # Three labelled lines then the profiles as JSON, matching the Node CLI.
+            # This used to print a `path` line and a one-line-per-profile summary,
+            # which told the user less and matched nothing.
             "text": lambda: "\n".join(
                 [
-                    f"{style.dim('path')} {data['path']}",
-                    *(
-                        f"{style.dim(('  ' + name).ljust(18))} "
-                        + ", ".join(f"{k}={v}" for k, v in entry.items())
-                        for name, entry in data["profiles"].items()
-                    ),
+                    f"{style.dim('file           ')} {config_module.config_path()}",
+                    f"{style.dim('active profile ')} {data.get('current_profile')}",
+                    f"{style.dim('key storage    ')} {credentials.describe_storage()}",
+                    "",
+                    json.dumps(data.get("profiles", {}), indent=2),
                 ]
             ),
         }
@@ -473,7 +551,9 @@ def config_command(ctx: dict) -> dict:
         if key not in _SETTABLE:
             raise usage_error(
                 f'"{key}" is not settable.',
-                f"Settable keys: {', '.join(sorted(_SETTABLE))}. The API key is "
+                # Declaration order, not sorted: the Node CLI lists them in the
+                # order they are declared and the two messages have to match.
+                f"Settable keys: {', '.join(_SETTABLE_ORDER)}. The API key is "
                 "never stored here; use `memorysync init`.",
             )
         if sub == "set" and len(positionals) < 3:

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/commands/init.py

@@ -75,21 +75,22 @@ def _init_as_agent(ctx: dict, profile_name: str) -> dict:
         "claim_command": minted.get("claim_command") or CLAIM_HINT,
         "limits": minted.get("limits"),
         "mcp_url": minted.get("mcp_url"),
-        "stored_in": tier,
-        "config": str(path),
+        # `base_url` and `credential_storage`, matching the Node CLI. This used to
+        # report `stored_in` ("file" / "keychain") and `config` (the config file
+        # path), so an agent reading the envelope from one CLI could not find the
+        # fields it found in the other.
+        "base_url": settings["base_url"],
+        "credential_storage": credentials.describe_storage(profile_name),
     }
 
     def render() -> str:
-        where = (
-            "the OS keychain" if tier == "keychain" else "an owner-only encrypted file"
-        )
         return "\n".join(
             [
                 style.green("Agent mode active."),
                 f"{style.dim('default user')} {payload['default_user_id'] or '-'}",
                 f"{style.dim('plan        ')} {payload['plan'] or '-'}",
                 f"{style.dim('expires     ')} {payload['expires_at'] or '-'}",
-                f"{style.dim('key stored  ')} in {where}",
+                f"{style.dim('key stored  ')} {credentials.describe_storage(profile_name)}",
                 "",
                 style.dim('Try: memorysync add "I prefer TypeScript"'),
                 "",
@@ -100,7 +101,9 @@ def _init_as_agent(ctx: dict, profile_name: str) -> dict:
             ]
         )
 
-    return {"data": payload, "text": render}
+    # The profile was just rewritten, so the envelope's scope must be re-read
+    # rather than reported from the settings resolved before this ran.
+    return {"data": payload, "text": render, "rescope": True}
 
 
 def _init_by_claiming(ctx: dict, profile_name: str) -> dict:
@@ -224,7 +227,9 @@ def identify(ctx: dict) -> dict:
             lines.append(style.dim("Nothing was stored under a different id."))
         return "\n".join(lines)
 
-    return {"data": payload, "text": render}
+    # `identify` exists to change the default end user, so the scope it reports
+    # has to be the new one.
+    return {"data": payload, "text": render, "rescope": True}
 
 
 def init(ctx: dict) -> dict:
@@ -330,4 +335,4 @@ def init(ctx: dict) -> dict:
             lines.append(f"{style.dim('plan     ')} {payload['plan']}")
         return "\n".join(lines)
 
-    return {"data": payload, "text": render}
+    return {"data": payload, "text": render, "rescope": True}

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/config.py

@@ -55,7 +55,9 @@ def config_path() -> Path:
 
 
 def _empty() -> dict[str, Any]:
-    return {"version": CONFIG_VERSION, "profiles": {}, "current_profile": "default"}
+    # Key order matches the Node CLI's EMPTY, so the config file each writes is
+    # byte-identical for the same content and `config show --json` agrees.
+    return {"version": CONFIG_VERSION, "current_profile": "default", "profiles": {}}
 
 
 def load() -> dict[str, Any]:
@@ -77,19 +79,22 @@ def load() -> dict[str, Any]:
 
     return {
         "version": parsed.get("version", CONFIG_VERSION),
-        "profiles": parsed.get("profiles") if isinstance(parsed.get("profiles"), dict) else {},
         # Preserved, not dropped. This key was being discarded on read, so the
         # Python CLI had no concept of an active profile at all: `config
         # use-profile work` wrote it and every later command still used "default",
         # and a profile switched under the Node CLI was ignored here. The two are
         # documented as interchangeable and share ~/.memorysync, so that was a real
         # divergence rather than a missing nicety.
+        #
+        # Ordered before `profiles` to match the Node CLI, so the file both write
+        # and the JSON both print come out in the same order.
         "current_profile": (
             parsed.get("current_profile")
             if isinstance(parsed.get("current_profile"), str)
             and parsed.get("current_profile")
             else "default"
         ),
+        "profiles": parsed.get("profiles") if isinstance(parsed.get("profiles"), dict) else {},
     }
 
 
@@ -190,11 +195,19 @@ def redacted(config: dict[str, Any] | None = None) -> dict[str, Any]:
     future field cannot be added and printed by accident.
     """
     data = config or load()
-    return {
-        "version": data.get("version", CONFIG_VERSION),
-        "path": str(config_path()),
-        "profiles": {
-            name: {key: value for key, value in entry.items() if key != "api_key"}
-            for name, entry in data.get("profiles", {}).items()
-        },
-    }
+
+    profiles: dict[str, Any] = {}
+    for name, entry in data.get("profiles", {}).items():
+        profiles[name] = dict(entry)
+        # An older version may have written a key here. Never echo it, and say so
+        # rather than dropping the field silently, which left the user with no clue
+        # that a credential was sitting in a plain-text file.
+        if profiles[name].get("api_key"):
+            profiles[name]["api_key"] = (
+                "(stored insecurely - run `memorysync init` to move it)"
+            )
+
+    # Every other key passes through, so `current_profile` reaches `config show`.
+    # This used to return a fixed set that omitted it and added `path`, so
+    # `config show --json` disagreed with the Node CLI on both counts.
+    return {**data, "version": data.get("version", CONFIG_VERSION), "profiles": profiles}

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/credentials.py

@@ -12,11 +12,25 @@ was not true on any platform:
   * keychain (macOS/Linux)  shared. Both use service ``memorysync-cli`` with the
                             profile name as the account. The account strings used
                             to differ, so neither found the other's entry.
-  * file (Windows)          NOT shared, and cannot be. Node encrypts with
-                            AES-256-GCM from ``node:crypto``; Python's standard
-                            library has no AES and this package takes no
-                            dependencies, so the two cannot read each other's
-                            blob. Running ``init`` under each is required.
+  * file (Windows)          shared, as of CLI 1.1.2. Node's own file is
+                            ``<profile>.enc``, AES-256-GCM, which Python's standard
+                            library cannot read - it has no AES and this package
+                            ships no dependencies. So the Node CLI now writes this
+                            module's ``<profile>.pyenc`` alongside its own and
+                            reads it as a fallback. Its AES file stays primary, so
+                            nobody has to migrate.
+
+                            Giving up AES for the shared copy costs nothing that
+                            was being protected: both keys are derived from
+                            hostname and username, which any process running as
+                            this user can read. Neither format resists a local
+                            attacker; both keep the key out of plain text and inert
+                            on another machine.
+
+                            Before this, ``init`` under npm followed by ``add``
+                            under pipx answered "No API key found" - and on
+                            Windows, where neither CLI reaches a keychain, that hit
+                            everyone who installed both.
 
 The file also moved from ``<config>/credentials`` to
 ``<config>/credentials/<profile>.pyenc``. Now that both CLIs share
@@ -270,15 +284,18 @@ def delete_key(profile: str = "default") -> None:
 
 
 def describe_storage(profile: str = "default") -> str:
-    """Human description of where a key would be stored, for `doctor`.
+    """Human description of where a key would be stored.
 
-    Says "this CLI only" on the file tier so a user who stored a key with the Node
-    CLI is told why it is not visible here, rather than being left to conclude the
-    key was never saved.
+    Matches the Node CLI's ``storageDescription()`` word for word. It used to read
+    "this CLI only", which was accurate at the time and is not any more: the Node
+    CLI now writes this same ``.pyenc`` file alongside its own, so a key stored by
+    either CLI is found by both.
     """
+    if os.environ.get(ENV_VAR):
+        return f"environment variable {ENV_VAR}"
     tool = _keychain_tool()
     if tool == "security":
-        return "macOS keychain (security), shared with the Node CLI"
+        return "macOS keychain"
     if tool == "secret-tool":
-        return "Linux keyring (secret-tool), shared with the Node CLI"
-    return f"encrypted file, owner-only, this CLI only ({_keyfile(profile)})"
+        return "Linux secret service"
+    return "encrypted file, readable only by this user on this machine"

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/errors.py

@@ -20,8 +20,6 @@ an empty database.
 
 from __future__ import annotations
 
-import platform
-
 from .registry import exit_codes
 
 _CODES = exit_codes()
@@ -82,23 +80,17 @@ def usage_error(message: str, hint: str | None = None) -> CliError:
 
 
 def _default_auth_hint() -> str:
-    """Why "no key" can be wrong-looking rather than wrong.
-
-    On Windows the two CLIs cannot share a stored key: Node encrypts with
-    AES-256-GCM and this package has no AES available without taking a dependency.
-    Someone who ran `memorysync init` seconds ago -- possibly reaching the *other*
-    CLI, since both install a binary of that name -- is otherwise told "No API key
-    found" by a machine that visibly has one, with nothing to act on.
+    """The hint shown when no credential can be found.
+
+    Identical to the Node CLI's. It used to add a Windows-only paragraph saying a
+    key stored by one CLI is invisible to the other, which was true when it was
+    written and is not any more: as of 1.1.2 the Node CLI writes this package's
+    `.pyenc` file alongside its own and reads it back, so either CLI finds a key
+    stored by either. Keeping the paragraph would now send people to re-run `init`
+    for a problem that no longer exists - and for an evaluation key that costs a
+    mint against the five-per-day cap.
     """
-    base = "Run `memorysync init` to store a key, or set MEMORYSYNC_API_KEY."
-    if platform.system() == "Windows":
-        return (
-            base
-            + " On Windows the Node and Python CLIs keep separate key files, so a"
-            + " key stored by one is not visible to the other; run init here too,"
-            + " or set MEMORYSYNC_API_KEY, which both read."
-        )
-    return base
+    return "Run `memorysync init` to store a key, or set MEMORYSYNC_API_KEY."
 
 
 def auth_error(message: str, hint: str | None = None) -> CliError:

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/main.py

@@ -154,8 +154,8 @@ def _reject_unknown_flags(flags: dict, allowed: set[str]) -> None:
     if unknown:
         spelled = ", ".join(f"--{key.replace('_', '-')}" for key in unknown)
         raise usage_error(
-            f"Unknown flag {spelled} for this command.",
-            "Run `memorysync help <command>` to see what it accepts.",
+            f"Unknown flag {spelled}.",
+            "Run the command with --help to see its flags.",
         )
 
 
@@ -174,9 +174,16 @@ def _fail(*, command: str, error: CliError, agent_mode: bool, started: float, se
             )
         )
     else:
-        print(style.red(f"error: {error.message}"), file=sys.stderr)
+        # Three plain lines, matching the Node CLI byte for byte. This used to
+        # print `error: ` before the message, indent the hint by two spaces, colour
+        # both, and omit the request id entirely - so the two CLIs disagreed on
+        # every failure, and the id needed to look up a failure in our logs was
+        # only available from one of them.
+        print(error.message, file=sys.stderr)
         if error.hint:
-            print(style.dim(f"  {error.hint}"), file=sys.stderr)
+            print(error.hint, file=sys.stderr)
+        if error.request_id:
+            print(f"Request id: {error.request_id}", file=sys.stderr)
     return error.exit_code
 
 
@@ -286,7 +293,16 @@ def dispatch(argv: list[str]) -> int:
                         command=command_name,
                         data=result["data"],
                         duration_ms=duration_ms,
-                        scope=_scope_of(settings),
+                        # A command that rewrote the profile has just invalidated
+                        # the settings resolved before it ran. `init --agent` is the
+                        # case that matters: it mints an account and stores a new
+                        # default end-user id, and reporting the previous one told
+                        # an agent to keep writing under the identity it just
+                        # replaced. Memories then split across two ids, which is the
+                        # one failure this whole flow exists to avoid.
+                        scope=_scope_of(
+                            _resolve_settings(flags) if result.get("rescope") else settings
+                        ),
                     ),
                     indent=2,
                 )
@@ -327,8 +343,36 @@ def dispatch(argv: list[str]) -> int:
         )
 
 
+def _force_utf8_streams() -> None:
+    """Write UTF-8 regardless of the platform's default encoding.
+
+    On Windows, an interactive console is UTF-8 capable but a *redirected* stdout
+    falls back to the ANSI code page, usually cp1252. That code page cannot encode
+    the box-drawing and block characters the tables and quota bars are built from,
+    so ``memorysync quota > usage.txt`` died with a UnicodeEncodeError and exit 1
+    while the same command printed fine to the terminal - a failure that only
+    appears once someone pipes or redirects, which is exactly what a script does.
+
+    Node has no equivalent problem because it writes UTF-8 to stdout unconditionally,
+    so this is also what keeps the two CLIs producing the same bytes.
+
+    ``errors="replace"`` is a backstop: a console that genuinely cannot represent a
+    character should degrade to a placeholder rather than abort a command that has
+    already written to the API.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:  # pragma: no cover - non-standard stream
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (ValueError, OSError):  # pragma: no cover - detached stream
+            pass
+
+
 def run(argv: list[str] | None = None) -> None:
     """Console-script entry point."""
+    _force_utf8_streams()
     args = list(sys.argv[1:] if argv is None else argv)
     try:
         raise SystemExit(dispatch(args))

{memorysync_cli-1.1.1 → memorysync_cli-1.1.2}/src/memorysync_cli/output.py

@@ -143,15 +143,29 @@ def render_table(
         for i in range(len(headers))
     ]
 
-    def line(cells: Sequence[str], dim: bool) -> str:
+    def line(cells: Sequence[str], painter: Any = None) -> str:
+        """One row. The painter colours the text but never the padding, so the
+        columns line up whether or not colour is on."""
         parts = []
         for index, cell in enumerate(cells):
             padding = " " * max(0, widths[index] - _display_width(cell))
-            parts.append(cell + padding)
-        joined = "  ".join(parts).rstrip()
-        return style.dim(joined) if dim else joined
+            parts.append((painter(cell) if painter else cell) + padding)
+        return "  ".join(parts).rstrip()
 
-    return "\n".join([line(list(headers), True), *(line(row, False) for row in materialised)])
+    # Header, hairline divider, then rows - byte for byte what the Node CLI's
+    # renderTable emits. The divider was missing here and the header was dimmed
+    # rather than bold, so every table in this CLI looked different from the same
+    # table in the Node one. The two are documented as interchangeable, so a
+    # script that diffs their output has to see the same bytes.
+    divider = "  ".join("\u2500" * width for width in widths)
+
+    return "\n".join(
+        [
+            line(list(headers), style.bold),
+            style.dim(divider),
+            *(line(row) for row in materialised),
+        ]
+    )
 
 
 # ---------------------------------------------------------------------------

memorysync_cli-1.1.1/src/memorysync_cli/_version.py

@@ -1 +0,0 @@
-__version__ = "1.1.1"