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

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

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

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

{memorysync_cli-1.1.2 → memorysync_cli-1.1.3}/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/src/memorysync_cli/_version.py

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