memorysync-cli 1.0.2__tar.gz → 1.0.3__tar.gz

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.0.2
+Version: 1.0.3
 Summary: MemorySync from your terminal. Zero dependencies.
 Project-URL: Documentation, https://docs.memorysync.io/cli
 Project-URL: Homepage, https://memorysync.io/cli
@@ -42,6 +42,32 @@ externally-managed Pythons — Homebrew and most Linux distributions — with
 
 Requires Python 3.9 or newer.
 
+### `memorysync: command not found` after installing
+
+The install worked; your shell cannot see the directory `pipx` puts binaries in.
+Run `pipx ensurepath`, then reopen the terminal. Or invoke it by full path —
+`pipx list` prints the location.
+
+To skip `PATH` entirely:
+
+```bash
+pipx run --spec memorysync-cli memorysync <command>
+```
+
+`--spec` is needed because `pipx run memorysync-cli` looks for a console script
+named after the package, and this package's scripts are `memorysync` and `msync`.
+
+### Both CLIs installed? Only one `memorysync` can win
+
+The npm package installs the same two command names, so whichever directory comes
+first on `PATH` answers. To run *this* one specifically, use the full path from
+`pipx list`, or `pipx run --spec` as above.
+
+`python -m memorysync_cli` works only when the package is installed into that
+interpreter with `pip install`. After a `pipx` install it will report
+`No module named memorysync_cli`, because pipx deliberately isolates the package
+in its own virtualenv.
+
 ## Getting started
 
 ```bash

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/README.md

@@ -17,6 +17,32 @@ externally-managed Pythons — Homebrew and most Linux distributions — with
 
 Requires Python 3.9 or newer.
 
+### `memorysync: command not found` after installing
+
+The install worked; your shell cannot see the directory `pipx` puts binaries in.
+Run `pipx ensurepath`, then reopen the terminal. Or invoke it by full path —
+`pipx list` prints the location.
+
+To skip `PATH` entirely:
+
+```bash
+pipx run --spec memorysync-cli memorysync <command>
+```
+
+`--spec` is needed because `pipx run memorysync-cli` looks for a console script
+named after the package, and this package's scripts are `memorysync` and `msync`.
+
+### Both CLIs installed? Only one `memorysync` can win
+
+The npm package installs the same two command names, so whichever directory comes
+first on `PATH` answers. To run *this* one specifically, use the full path from
+`pipx list`, or `pipx run --spec` as above.
+
+`python -m memorysync_cli` works only when the package is installed into that
+interpreter with `pip install`. After a `pipx` install it will report
+`No module named memorysync_cli`, because pipx deliberately isolates the package
+in its own virtualenv.
+
 ## Getting started
 
 ```bash

memorysync_cli-1.0.3/src/memorysync_cli/_version.py

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

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/src/memorysync_cli/commands/admin.py

@@ -126,7 +126,7 @@ def whoami(ctx: dict) -> dict:
         "user": settings.get("user"),
         "project": settings.get("project"),
         "plan": plan.get("plan") or plan.get("name"),
-        "credential_source": credentials.describe_storage(),
+        "credential_source": credentials.describe_storage(settings["profile_name"]),
     }
 
     def render() -> str:
@@ -168,14 +168,23 @@ def doctor(ctx: dict) -> dict:
     )
     add("cli", True, f"memorysync-cli {__version__}")
     add("config", True, str(config_module.config_path()))
-    add("credential store", True, credentials.describe_storage())
+    add("credential store", True, credentials.describe_storage(settings["profile_name"]))
 
     key = credentials.read_key(settings["profile_name"])
     add(
         "api key",
         bool(key),
         f"found ({key[:8]}...)" if key else "not found",
-        None if key else "Run `memorysync init`, or set MEMORYSYNC_API_KEY.",
+        # Names the cross-CLI case explicitly. Someone who ran `init` moments ago
+        # and is told "not found" will otherwise reasonably conclude the CLI is
+        # broken, when on Windows the key is simply in the other CLI's store.
+        None
+        if key
+        else (
+            "Run `memorysync init`, or set MEMORYSYNC_API_KEY. If you stored a key "
+            "with the Node CLI on Windows, it is not shared: the two use different "
+            "ciphers, so run init here as well."
+        ),
     )
     add(
         "end user",

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/src/memorysync_cli/config.py

@@ -1,9 +1,17 @@
 """Profiles and settings, resolved in one documented order.
 
 Precedence, highest first: an explicit flag, then the environment, then the config
-file, then a built-in default. That order is what people expect and, more
-importantly, it is what the Node CLI does, so a script that sets
-``MEMORYSYNC_USER`` behaves the same whichever CLI is installed.
+file, then a built-in default. That order is what people expect and it is what the
+Node CLI does.
+
+Environment variable names are the Node CLI's, which are also the ones the
+documentation lists. This module previously read ``MEMORYSYNC_USER`` and
+``MEMORYSYNC_PROJECT`` while Node read ``MEMORYSYNC_USER_ID`` and
+``MEMORYSYNC_PROJECT_ID``, and its own docstring claimed the two agreed. They did
+not: every documented example that exported a default user worked under one CLI
+and was silently ignored by the other, which then failed with "this command needs
+an end user" and no indication why. The shorter names are still accepted as
+aliases, because they were published and someone may have used them.
 
 The config file never holds a credential. It holds a profile name, a default end
 user, a project and a base URL - the things that are useful to read, commit to a
@@ -23,23 +31,23 @@ DEFAULT_TIMEOUT_MS = 60000
 
 
 def config_dir() -> Path:
-    """Where settings live.
+    """Where settings live: ``~/.memorysync``, the same place the Node CLI uses.
 
     ``MEMORYSYNC_CONFIG_DIR`` is honoured first so tests and CI can point at a
     scratch directory instead of a developer's real profile.
+
+    This used to follow per-platform conventions - ``%APPDATA%\\memorysync`` on
+    Windows, ``$XDG_CONFIG_HOME/memorysync`` elsewhere - which is defensible on its
+    own but meant the two CLIs kept separate profile files. Running ``init`` under
+    one and a command under the other produced "No API key found" from a machine
+    that plainly had one, and the documentation's ``~/.memorysync`` was simply
+    wrong for this CLI. One location, shared, so a profile created by either is
+    seen by both.
     """
     override = os.environ.get("MEMORYSYNC_CONFIG_DIR")
     if override:
         return Path(override)
-
-    if os.name == "nt":
-        base = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
-        return Path(base) / "memorysync"
-
-    xdg = os.environ.get("XDG_CONFIG_HOME")
-    if xdg:
-        return Path(xdg) / "memorysync"
-    return Path.home() / ".config" / "memorysync"
+    return Path.home() / ".memorysync"
 
 
 def config_path() -> Path:
@@ -102,13 +110,20 @@ def resolve(flags: dict[str, Any]) -> dict[str, Any]:
     )
     stored = profile(profile_name)
 
-    def pick(flag_key: str, env_key: str, stored_key: str, fallback: Any = None) -> Any:
+    def pick(
+        flag_key: str,
+        env_keys: str | tuple[str, ...],
+        stored_key: str,
+        fallback: Any = None,
+    ) -> Any:
         value = flags.get(flag_key)
         if value not in (None, False):
             return value
-        env_value = os.environ.get(env_key)
-        if env_value:
-            return env_value
+        names = (env_keys,) if isinstance(env_keys, str) else env_keys
+        for name in names:
+            env_value = os.environ.get(name)
+            if env_value:
+                return env_value
         if stored.get(stored_key) is not None:
             return stored[stored_key]
         return fallback
@@ -124,8 +139,17 @@ def resolve(flags: dict[str, Any]) -> dict[str, Any]:
         "base_url": str(
             pick("base_url", "MEMORYSYNC_BASE_URL", "base_url", DEFAULT_BASE_URL)
         ).rstrip("/"),
-        "user": pick("user", "MEMORYSYNC_USER", "user"),
-        "project": pick("project", "MEMORYSYNC_PROJECT", "project"),
+        # ``_ID`` first: that is the documented name and what the Node CLI reads.
+        # The shorter form stays as an alias rather than being dropped, because it
+        # shipped and silently ignoring it would be a second surprise.
+        "user": pick("user", ("MEMORYSYNC_USER_ID", "MEMORYSYNC_USER"), "user"),
+        "project": pick(
+            "project", ("MEMORYSYNC_PROJECT_ID", "MEMORYSYNC_PROJECT"), "project"
+        ),
+        # Read here as well as in ``main`` so a format stored on the profile is
+        # honoured. Node resolves it from the profile too; omitting it meant
+        # `-o table` saved into a profile worked under one CLI only.
+        "output": pick("output", "MEMORYSYNC_OUTPUT", "output"),
         "timeout": timeout,
     }
 

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/src/memorysync_cli/credentials.py

@@ -1,8 +1,27 @@
 """Where the API key lives.
 
 Three tiers, in order: the environment, then the OS keychain, then an encrypted
-file readable only by the owner. Same order as the Node CLI, and reached through
-the same OS tools, so a key stored by one CLI is found by the other.
+file readable only by the owner. Same order as the Node CLI and reached through the
+same OS tools.
+
+How much is shared with the Node CLI, precisely, because the previous version of
+this docstring claimed "a key stored by one CLI is found by the other" and that
+was not true on any platform:
+
+  * ``MEMORYSYNC_API_KEY``  shared. Same variable, wins everywhere.
+  * 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.
+
+The file also moved from ``<config>/credentials`` to
+``<config>/credentials/<profile>.pyenc``. Now that both CLIs share
+``~/.memorysync``, a single file at that path would collide with the directory
+Node creates there, and writing to it would fail with "is a directory".
 
 Stated plainly, because it affects what a customer should expect:
 
@@ -38,11 +57,24 @@ ENV_VAR = "MEMORYSYNC_API_KEY"
 
 
 def _account(profile: str) -> str:
-    return f"{SERVICE}:{profile}"
+    """The keychain account, matching the Node CLI exactly.
+
+    Was ``f"{SERVICE}:{profile}"`` while Node used the bare profile name, under the
+    same service. Two entries, neither CLI finding the other's, on the two
+    platforms where a real keychain exists and sharing was actually possible.
+    """
+    return profile
 
 
-def _keyfile() -> Path:
-    return config_dir() / "credentials"
+def _keyfile(profile: str = "default") -> Path:
+    """One file per profile, inside the directory the Node CLI already uses.
+
+    A distinct extension rather than a distinct directory: the blobs are not
+    interchangeable (different ciphers) but they are the same kind of thing, and
+    keeping them together means ``credentials/`` is still the one place to look,
+    and to delete.
+    """
+    return config_dir() / "credentials" / f"{profile}.pyenc"
 
 
 def _obfuscation_key() -> bytes:
@@ -170,47 +202,37 @@ def _keychain_delete(profile: str) -> bool:
 
 
 def _file_read(profile: str) -> str | None:
-    path = _keyfile()
+    path = _keyfile(profile)
     try:
-        raw = path.read_text(encoding="utf-8")
-    except (FileNotFoundError, OSError):
+        blob = path.read_text(encoding="utf-8").strip()
+    except (FileNotFoundError, OSError, IsADirectoryError):
+        return None
+    if not blob:
+        return None
+    try:
+        return _xor(base64.b64decode(blob), _obfuscation_key()).decode("utf-8")
+    except Exception:  # noqa: BLE001 - a corrupt file is a miss, not a crash
         return None
-
-    for line in raw.splitlines():
-        name, _, blob = line.partition("=")
-        if name != profile or not blob:
-            continue
-        try:
-            return _xor(base64.b64decode(blob), _obfuscation_key()).decode("utf-8")
-        except Exception:  # noqa: BLE001 - a corrupt line is a miss, not a crash
-            return None
-    return None
 
 
 def _file_write(profile: str, key: str | None) -> None:
-    path = _keyfile()
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    entries: dict[str, str] = {}
-    try:
-        for line in path.read_text(encoding="utf-8").splitlines():
-            name, _, blob = line.partition("=")
-            if name and blob:
-                entries[name] = blob
-    except (FileNotFoundError, OSError):
-        pass
+    path = _keyfile(profile)
 
     if key is None:
-        entries.pop(profile, None)
-    else:
-        entries[profile] = base64.b64encode(_xor(key.encode("utf-8"), _obfuscation_key())).decode("ascii")
+        try:
+            path.unlink()
+        except (FileNotFoundError, OSError):
+            pass
+        return
 
-    # Written 0600 before any content lands, so there is no window where the file
+    path.parent.mkdir(parents=True, exist_ok=True)
+    blob = base64.b64encode(_xor(key.encode("utf-8"), _obfuscation_key())).decode("ascii")
+
+    # Opened 0600 before any content lands, so there is no window in which the file
     # exists with default permissions.
     descriptor = os.open(str(path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
     with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
-        for name, blob in entries.items():
-            handle.write(f"{name}={blob}\n")
+        handle.write(blob + "\n")
 
 
 # ---------------------------------------------------------------------------
@@ -247,13 +269,16 @@ def delete_key(profile: str = "default") -> None:
     _file_write(profile, None)
 
 
-def describe_storage() -> str:
-    """Human description of where a key would be stored, for `doctor`."""
+def describe_storage(profile: str = "default") -> str:
+    """Human description of where a key would be stored, for `doctor`.
+
+    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.
+    """
     tool = _keychain_tool()
     if tool == "security":
-        return "macOS keychain (security)"
+        return "macOS keychain (security), shared with the Node CLI"
     if tool == "secret-tool":
-        return "Linux keyring (secret-tool)"
-    if platform.system() == "Windows":
-        return f"encrypted file, owner-only ({_keyfile()})"
-    return f"encrypted file, owner-only ({_keyfile()}) - no keychain tool found"
+        return "Linux keyring (secret-tool), shared with the Node CLI"
+    return f"encrypted file, owner-only, this CLI only ({_keyfile(profile)})"

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/src/memorysync_cli/errors.py

@@ -20,6 +20,8 @@ an empty database.
 
 from __future__ import annotations
 
+import platform
+
 from .registry import exit_codes
 
 _CODES = exit_codes()
@@ -79,12 +81,32 @@ def usage_error(message: str, hint: str | None = None) -> CliError:
     return CliError(message, exit_code=Exit.USAGE, code="usage_error", hint=hint)
 
 
+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.
+    """
+    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
+
+
 def auth_error(message: str, hint: str | None = None) -> CliError:
     return CliError(
         message,
         exit_code=Exit.AUTH,
         code="auth_error",
-        hint=hint or "Run `memorysync init` to store a key, or set MEMORYSYNC_API_KEY.",
+        hint=hint or _default_auth_hint(),
     )
 
 

{memorysync_cli-1.0.2 → memorysync_cli-1.0.3}/src/memorysync_cli/output.py

@@ -33,10 +33,18 @@ _SEXAGESIMAL = re.compile(r"^\d+(:\d+)+$")
 
 
 def _colour_default() -> bool:
+    """Same decision the Node CLI makes, including ``TERM=dumb``.
+
+    ``TERM=dumb`` was honoured by Node and ignored here, so a terminal that
+    announces it cannot render ANSI got escape codes from one CLI and clean text
+    from the other.
+    """
     if os.environ.get("NO_COLOR"):
         return False
     if os.environ.get(_FORCE_COLOR):
         return True
+    if os.environ.get("TERM") == "dumb":
+        return False
     return bool(getattr(sys.stdout, "isatty", lambda: False)())
 
 

memorysync_cli-1.0.2/src/memorysync_cli/_version.py

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