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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.1.2
+Version: 1.1.4
 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.4/src/memorysync_cli/_version.py

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

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

@@ -24,7 +24,7 @@ from .. import credentials
 from .._version import __version__
 from ..errors import usage_error
 from ..evaluation import is_evaluation_key
-from ..output import render_table, style
+from ..output import dumps, render_table, style
 
 #: Keys ``config set`` / ``config unset`` accept. Identical to the Node CLI's
 #: ``SETTABLE``; ``output`` was previously missing here, so `config set output table`
@@ -457,7 +457,7 @@ def config_command(ctx: dict) -> dict:
                     f"{style.dim('active profile ')} {data.get('current_profile')}",
                     f"{style.dim('key storage    ')} {credentials.describe_storage()}",
                     "",
-                    json.dumps(data.get("profiles", {}), indent=2),
+                    dumps(data.get("profiles", {})),
                 ]
             ),
         }

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

@@ -147,10 +147,27 @@ def _init_by_claiming(ctx: dict, profile_name: str) -> dict:
                         "Your existing key keeps working and no longer expires. "
                         "Everything stored during the evaluation is still there."
                     ),
+                    "",
+                    # Owning the account and being able to open the dashboard are
+                    # two different things, and this used to stop before saying
+                    # so. Without ``--password`` there is no credential yet, and
+                    # the only way in is a link labelled "Forgot password" —
+                    # which nobody should have to guess at for a password they
+                    # never had. The server says which case this is; print its
+                    # sentence rather than deciding here, so the two CLIs and the
+                    # API cannot drift on the instruction.
+                    style.yellow(claimed["next_step"])
+                    if claimed.get("next_step")
+                    else style.dim(
+                        "Sign in at https://app.memorysync.io/login with this address."
+                    ),
                 ]
             )
 
-        return {"data": payload, "text": render_complete}
+        # The profile now records that the account is owned, so the reminder must
+        # be re-evaluated from disk rather than from the settings resolved before
+        # this ran.
+        return {"data": payload, "text": render_complete, "rescope": True}
 
     # The value ``main`` already resolved from --api-key, the environment, then the
     # stored profile. Resolving it again here would be a second precedence order

{memorysync_cli-1.1.2 → memorysync_cli-1.1.4}/src/memorysync_cli/commands/memory.py

@@ -22,7 +22,7 @@ from typing import Any
 
 from ..errors import quota_error, usage_error
 from ..http import ApiClient
-from ..output import render_table, style
+from ..output import dumps, render_table, style
 
 
 def _require_user(ctx: dict) -> str:
@@ -608,12 +608,15 @@ def export_memories(ctx: dict) -> dict:
 
 
 def _serialize_export(memories: list[dict], fmt: str) -> str:
+    # Through the shared helper: an export is a file a customer keeps, and
+    # escaping every accent to ``\\uXXXX`` made this CLI's export a different
+    # document from the Node CLI's for the same memories.
     if fmt == "json":
-        return json.dumps(memories, indent=2) + "\n"
+        return dumps(memories) + "\n"
     if fmt == "jsonl":
         if not memories:
             return ""
-        return "\n".join(json.dumps(item) for item in memories) + "\n"
+        return "\n".join(dumps(item, indent=None) for item in memories) + "\n"
 
     # CSV, quoted by hand rather than through the csv module so the output is
     # identical to the Node CLI's, which also writes it directly.

{memorysync_cli-1.1.2 → memorysync_cli-1.1.4}/src/memorysync_cli/http.py

@@ -121,13 +121,25 @@ class ApiClient:
         started = time.monotonic()
         request = urllib.request.Request(url, data=payload, headers=headers, method=method)
 
+        # Headers are kept, not discarded: the API returns the request id in
+        # `x-request-id`, and it is the only handle support has on a failure. The
+        # Node CLI printed it and this one did not.
+        response_headers: Any = None
+        status_reason = ""
+
         try:
             with urllib.request.urlopen(request, timeout=limit_ms / 1000) as response:
                 text = response.read().decode("utf-8", errors="replace")
                 status = response.status
+                response_headers = response.headers
         except urllib.error.HTTPError as error:
             text = error.read().decode("utf-8", errors="replace")
             status = error.code
+            response_headers = error.headers
+            # The status phrase, so a body with no usable message reads
+            # "400 Bad Request" as it does under the Node CLI, rather than this
+            # CLI's own wording.
+            status_reason = str(getattr(error, "reason", "") or "")
         except TimeoutError:
             raise network_error(
                 f"Request to {path} timed out after {limit_ms}ms.",
@@ -156,25 +168,129 @@ class ApiClient:
         if 200 <= status < 300:
             return parsed
 
-        raise self._to_error(status, parsed)
+        raise self._to_error(status, parsed, response_headers, status_reason)
+
+    @staticmethod
+    def _request_id(payload: Any, headers: Any) -> str | None:
+        from_header = headers.get("x-request-id") if headers is not None else None
+        if from_header:
+            return from_header
+        if isinstance(payload, dict) and isinstance(payload.get("request_id"), str):
+            return payload["request_id"]
+        return None
+
+    def _from_oauth_error(
+        self, status: int, body: dict, request_id: str | None, headers: Any
+    ) -> CliError:
+        """An ``{error, error_description}`` body, as ``/evaluation/*`` returns.
+
+        The exit code comes from the code rather than the HTTP status, because the
+        status cannot separate these: a refused claim and an already-claimed
+        account are both 409, and only one of them is worth retrying with
+        different input. Mirrors ``#fromOAuthError`` in the Node CLI.
+        """
+        code = body["error"]
+        message = body["error_description"]
+
+        if code == "rate_limited":
+            retry_after = headers.get("retry-after") if headers is not None else None
+            return CliError(
+                message,
+                exit_code=Exit.NETWORK,
+                code=code,
+                hint=(
+                    f"Wait {retry_after} seconds and try again."
+                    if retry_after
+                    else "Wait and try again."
+                ),
+                request_id=request_id,
+            )
+
+        # Wrong input the caller can correct, or a state it cannot argue with.
+        # Both are exit 2: the fix is a different command, not a retry.
+        correctable = {
+            "invalid_email",
+            "email_already_registered",
+            "invalid_code",
+            "code_expired",
+            "too_many_attempts",
+            "not_an_evaluation_key",
+            "already_claimed",
+            "unclaimable",
+        }
+        if code in correctable:
+            return CliError(
+                message, exit_code=Exit.USAGE, code=code, request_id=request_id
+            )
 
-    def _to_error(self, status: int, payload: Any) -> CliError:
+        if status in (401, 403):
+            return auth_error(message)
+        if status == 404:
+            return not_found_error(message)
+        return CliError(
+            message, exit_code=Exit.FAILURE, code=code, request_id=request_id
+        )
+
+    def _to_error(
+        self,
+        status: int,
+        payload: Any,
+        headers: Any = None,
+        reason: str = "",
+    ) -> CliError:
         """Map a failed response to the taxonomy.
 
+        Mirrors ``#toError`` in ``sdk/cli/src/http.mjs`` step for step. The
+        unwrapping below is the part that had drifted: this CLI treated ``detail``
+        itself as the carrier and never looked inside ``detail.error``, so the
+        nested shape the API uses on several routes lost both its sentence and its
+        code and fell through to a generic "Request failed with status 400."
+
         The status alone is not enough for 429: a plan limit and a rate limit both
         arrive as 429 but mean different things to a script. Only the first is
         about the plan, and only the first is pointless to retry.
         """
-        detail = payload.get("detail") if isinstance(payload, dict) else None
-        inner = detail if isinstance(detail, dict) else None
-        message = (
-            (inner or {}).get("message")
-            or (detail if isinstance(detail, str) else None)
-            or (payload.get("message") if isinstance(payload, dict) else None)
-            or f"Request failed with status {status}."
-        )
-        code = (inner or {}).get("code")
+        request_id = self._request_id(payload, headers)
+
+        # Node: `payload?.detail ?? payload`
+        detail: Any = payload
+        if isinstance(payload, dict) and payload.get("detail") is not None:
+            detail = payload["detail"]
+
+        # `/evaluation/*` answers in the OAuth error shape. Without this branch the
+        # sentence in `error_description` was dropped entirely and this CLI
+        # reported "Request failed with status 409." for a refused claim, while the
+        # Node CLI reported the bare code `email_already_registered`. Neither told
+        # the user that the address already has an account.
+        if (
+            isinstance(detail, dict)
+            and isinstance(detail.get("error"), str)
+            and isinstance(detail.get("error_description"), str)
+        ):
+            return self._from_oauth_error(status, detail, request_id, headers)
+
+        # Node: `detail?.error ?? detail`
+        inner: Any = detail
+        if isinstance(detail, dict) and detail.get("error") is not None:
+            inner = detail["error"]
+
+        message = inner if isinstance(inner, str) else None
+        if message is None and isinstance(inner, dict):
+            message = inner.get("message")
+        if not message and isinstance(payload, dict):
+            message = payload.get("message")
+        if not message:
+            message = f"{status} {reason}".strip() if reason else (
+                f"Request failed with status {status}."
+            )
 
+        code = inner.get("code") if isinstance(inner, dict) else None
+
+        # Every branch below matches the Node CLI's `#toError`, including exit
+        # codes. They had drifted: a 500 exited 5 here and 1 there, so a script
+        # retrying on "network" retried a server error under one CLI and gave up
+        # under the other. The fallback code was `api_error` here and
+        # `http_<status>` there, and the request id was dropped here entirely.
         if status in (401, 403):
             return auth_error(message)
         if status == 404:
@@ -188,17 +304,34 @@ class ApiClient:
             return CliError(
                 message,
                 exit_code=Exit.NETWORK,
-                code="rate_limited",
+                code=code or "rate_limited",
                 hint="Too many requests. Wait and retry.",
+                request_id=request_id,
+            )
+        if code == "MISSING_END_USER_ID":
+            return CliError(
+                "This command needs an end user.",
+                exit_code=Exit.USAGE,
+                code=code,
+                hint="Pass --user <id>, or set a default with `memorysync init --user <id>`.",
+                request_id=request_id,
             )
         if status >= 500:
             return CliError(
-                message,
-                exit_code=Exit.NETWORK,
+                f"The API returned {status}: {message}",
+                exit_code=Exit.FAILURE,
                 code="server_error",
-                hint="The API failed. Retry, and check status if it persists.",
+                hint=(
+                    f"Quote request id {request_id} to support." if request_id else None
+                ),
+                request_id=request_id,
             )
-        return CliError(message, exit_code=Exit.FAILURE, code=code or "api_error")
+        return CliError(
+            message,
+            exit_code=Exit.FAILURE,
+            code=code or f"http_{status}",
+            request_id=request_id,
+        )
 
     # -----------------------------------------------------------------------
     # Named endpoints, so commands never carry raw paths

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

@@ -24,6 +24,7 @@ from .errors import CliError, Exit, auth_error, usage_error
 from .evaluation import claim_reminder
 from .http import ApiClient
 from .output import (
+    dumps,
     emit,
     error_envelope,
     set_colour_enabled,
@@ -163,7 +164,7 @@ def _fail(*, command: str, error: CliError, agent_mode: bool, started: float, se
     duration_ms = int((time.monotonic() - started) * 1000)
     if agent_mode:
         write(
-            json.dumps(
+            dumps(
                 error_envelope(
                     command=command,
                     error=error,
@@ -277,37 +278,39 @@ def dispatch(argv: list[str]) -> int:
         result = handler(ctx)
         duration_ms = int((time.monotonic() - started) * 1000)
 
+        # A command that rewrote the profile has invalidated the settings resolved
+        # before it ran, so re-read them once and use them for everything below.
+        #
+        # Two things depend on this. `init --agent` stores a new default end-user
+        # id, and reporting the previous one in `scope` told an agent to keep
+        # writing under the identity it had just replaced. And
+        # `init --email ... --code` records that the account is now owned, without
+        # which the CLI printed "This is an unclaimed evaluation key and expires"
+        # immediately after a successful claim — nagging about the exact thing the
+        # user had just done.
+        effective = _resolve_settings(flags) if result.get("rescope") else settings
+
         # `help` is a discovery contract, not a data result, so its JSON is the
         # tree itself rather than an envelope around it. An agent bootstrapping
         # from `help --json` should not have to reach into `.data[0]` for the
         # command list.
         if command_name == "help" and (agent_mode or fmt == "json"):
-            write(json.dumps(result["data"], indent=2))
-            _note_unclaimed_key(api_key, settings)
+            write(dumps(result["data"]))
+            _note_unclaimed_key(api_key, effective)
             return Exit.OK
 
         if agent_mode:
             write(
-                json.dumps(
+                dumps(
                     success_envelope(
                         command=command_name,
                         data=result["data"],
                         duration_ms=duration_ms,
-                        # 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,
+                        scope=_scope_of(effective),
+                    )
                 )
             )
-            _note_unclaimed_key(api_key, settings)
+            _note_unclaimed_key(api_key, effective)
             return result.get("exit_code", Exit.OK)
 
         # `completion` and `mcp` emit text that must not be decorated or reshaped.
@@ -321,7 +324,7 @@ def dispatch(argv: list[str]) -> int:
             return result.get("exit_code", Exit.OK)
 
         emit(fmt=fmt, data=result["data"], text=result["text"])
-        _note_unclaimed_key(api_key, settings)
+        _note_unclaimed_key(api_key, effective)
         return result.get("exit_code", Exit.OK)
 
     except CliError as error:

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

@@ -204,7 +204,9 @@ def _yaml_scalar(value: Any) -> str:
         # Sexagesimal: `12:30` is a number to a 1.1 parser.
         or _SEXAGESIMAL.match(text) is not None
     )
-    return json.dumps(text) if ambiguous else text
+    # Quoted through the shared helper so a value needing quotes in YAML is not
+    # also ASCII-escaped, which the Node CLI does not do.
+    return dumps(text, indent=None) if ambiguous else text
 
 
 def to_yaml(value: Any, indent: int = 0) -> str:
@@ -316,13 +318,36 @@ def write(text: str) -> None:
     sys.stdout.write(f"{text}\n")
 
 
+def dumps(data: Any, *, indent: int | None = 2) -> str:
+    """JSON exactly as the Node CLI's ``JSON.stringify`` writes it.
+
+    ``ensure_ascii=False`` is the whole point. Python escapes non-ASCII by
+    default, so an em-dash came out as ``\\u2014`` here and as the character
+    itself there — the same document in different bytes, from two CLIs published
+    as interchangeable. It showed up on a claim response whose sentence contains
+    one, and it would have applied to every ``--json`` payload carrying any
+    non-ASCII text, which for a memory store is most of them: any customer
+    memory containing an accent, a dash or an emoji.
+
+    Separators are pinned too, because Python's defaults leave a trailing space
+    after ``,`` when no indent is given and JavaScript does not.
+
+    Every user-facing JSON write goes through here so the two cannot drift again.
+    Request bodies deliberately do not: those are read by our own API, which
+    decodes both spellings to the same string, and no user ever sees them.
+    """
+    if indent is None:
+        return json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+    return json.dumps(data, indent=indent, ensure_ascii=False)
+
+
 def emit(*, fmt: str, data: Any, text: Callable[[], str]) -> None:
     """Render one result.
 
     ``text`` stays lazy so a JSON caller never pays to build a table it discards.
     """
     if fmt == "json":
-        write(json.dumps(data, indent=2))
+        write(dumps(data))
         return
     if fmt == "yaml":
         write(to_yaml(data))

memorysync_cli-1.1.2/src/memorysync_cli/_version.py

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