rly 0.2.0__py3-none-win_amd64.whl

rly/__init__.py

@@ -0,0 +1,5 @@
+"""PyPI launcher for the ReplyLayer CLI."""
+
+from importlib.metadata import version
+
+__version__ = version("rly")

rly/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

rly/_binaries/.gitkeep

@@ -0,0 +1,6 @@
+# Placeholder so rly/_binaries/ exists in source even when empty.
+# The per-platform CI matrix in `.github/workflows/build-cli-binaries.yml`
+# drops the matching `replylayer` (or `replylayer.exe`) binary into this
+# directory before running `python -m build`. The binary is .gitignored
+# (see ../../.gitignore) but Hatch wheel-target `artifacts` ensures it
+# lands in the wheel anyway (see ../../pyproject.toml).

rly/cli.py

@@ -0,0 +1,215 @@
+"""Bundled-binary launcher for the ReplyLayer CLI.
+
+Resolution order (see plans/cli-bundled-binary-launcher.md §4.3):
+
+  1. RLY_FORCE_NPX=1 → legacy `npx replylayer@<pinned>` path (W3 logic,
+     RLY_OFFLINE-aware). Reachable BEFORE binary resolution so callers
+     on musl/Alpine (where _resolve_bundled_binary returns None) still
+     have an out if Node is on PATH.
+  2. Bundled binary at `rly/_binaries/replylayer[.exe]` → direct exec.
+  3. Missing binary (sdist install on unsupported platform OR corrupted
+     wheel) → exit 1 with an actionable error.
+
+Env-var contract:
+
+  RLY_TIMEOUT_SECONDS: opt-in subprocess timeout (carry-over from W3).
+                      10s default for --help/--version quick commands.
+                      Unbounded for everything else.
+  RLY_FORCE_NPX=1:    use the legacy npx fallback (emergency / dev path).
+  RLY_OFFLINE=1:      no-op for the binary path; in the npx fallback,
+                      injects `npx --offline` + `npm_config_offline=true`
+                      (W3 behavior preserved per rev. 5 audit finding 3).
+
+This module's `main()` is registered as the `rly` console-script entry
+point via packages/pypi-rly/pyproject.toml [project.scripts].
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from collections.abc import Sequence
+from importlib.metadata import version
+from importlib.resources import files
+
+QUICK_COMMAND_TIMEOUT_SECONDS = 10
+QUICK_COMMAND_ARGS = frozenset({"--help", "-h", "--version", "-V"})
+
+
+def _binary_name() -> str:
+    return "replylayer.exe" if sys.platform == "win32" else "replylayer"
+
+
+def _resolve_bundled_binary() -> str | None:
+    """Return the path to the bundled binary, or None if missing.
+
+    Missing-bundled-binary cases:
+      - sdist install on an unsupported platform (no _binaries/ dir).
+      - Editable / source install during local development.
+      - Corrupted wheel.
+
+    Note: this does NOT check the host's libc — on a musl host that
+    somehow installed a glibc wheel (e.g. forced via --no-binary), the
+    binary file exists but exec'ing it will fail. The launcher returns
+    the path here regardless; the caller's subprocess.run() will surface
+    the dynamic-loader error and Python exits with the resulting code.
+    The fall-clear platform-support message from _no_binary_error() runs
+    only when the file is genuinely missing.
+    """
+    try:
+        ref = files("rly._binaries").joinpath(_binary_name())
+        # importlib.resources returns a Traversable; for a wheel install,
+        # this is a real on-disk path. Defensive: handle both is_file()
+        # missing (zip-imported edge case) and a stale .gitkeep-only dir.
+        if hasattr(ref, "is_file") and ref.is_file():
+            return str(ref)
+    except (FileNotFoundError, ModuleNotFoundError):
+        return None
+    return None
+
+
+def _resolve_timeout(args: list[str]) -> int | None:
+    env_timeout = os.environ.get("RLY_TIMEOUT_SECONDS")
+    if env_timeout:
+        try:
+            return int(env_timeout)
+        except ValueError:
+            return None
+    if any(a in QUICK_COMMAND_ARGS for a in args):
+        return QUICK_COMMAND_TIMEOUT_SECONDS
+    return None
+
+
+def _no_binary_error() -> str:
+    try:
+        pinned = version("rly")
+    except Exception:
+        pinned = "<unknown>"
+    return (
+        f"rly: no bundled replylayer binary found for this install.\n"
+        f"This usually means a source/sdist install on an unsupported platform.\n"
+        f"\n"
+        f"Supported platforms (binary wheel published):\n"
+        f"  - linux x86_64 / aarch64 (glibc 2.28+)\n"
+        f"  - macOS arm64 / x86_64 (>= 14.0)\n"
+        f"  - Windows x64 (>= Windows 10 / Server 2016)\n"
+        f"\n"
+        f"If you have Node 22+ on PATH, you can use the legacy npx path:\n"
+        f"  RLY_FORCE_NPX=1 rly ...\n"
+        f"\n"
+        f"To force installation of the binary wheel from PyPI:\n"
+        f"  pipx install --force --pip-args='--only-binary=:all:' rly=={pinned}\n"
+    )
+
+
+def _run_npx_fallback(args: list[str]) -> int:
+    """Emergency fallback to `npx --yes replylayer@<pinned>`.
+
+    Preserves the W3 hardening (RLY_OFFLINE -> npx --offline +
+    npm_config_offline=true) byte-for-byte from the pre-rev-11
+    packages/pypi-rly/rly/cli.py:52 (rev. 5 audit finding 3 — the rev. 4
+    draft dropped this and lost W3's offline contract).
+    """
+    import shutil
+
+    npx = shutil.which("npx")
+    if npx is None:
+        print(
+            "rly: RLY_FORCE_NPX=1 requested but npx is not on PATH. "
+            "Install Node.js 22+ with npm, or remove RLY_FORCE_NPX.",
+            file=sys.stderr,
+        )
+        return 127
+
+    try:
+        pinned = version("rly")
+    except Exception as exc:
+        print(
+            f"rly: could not resolve installed package version ({exc}). "
+            "Reinstall rly: `pipx reinstall rly`.",
+            file=sys.stderr,
+        )
+        return 1
+
+    env = os.environ.copy()
+    env.setdefault("npm_config_update_notifier", "false")
+
+    offline = os.environ.get("RLY_OFFLINE") == "1"
+    if offline:
+        env["npm_config_offline"] = "true"
+
+    cmd = [npx]
+    if offline:
+        cmd.append("--offline")
+    cmd.extend(["--yes", f"replylayer@{pinned}", *args])
+
+    timeout_s = _resolve_timeout(args)
+    try:
+        completed = subprocess.run(cmd, env=env, check=False, timeout=timeout_s)
+        return completed.returncode
+    except subprocess.TimeoutExpired:
+        if offline:
+            print(
+                f"rly: npx fallback did not complete within {timeout_s}s. "
+                f"Offline mode is enabled; replylayer@{pinned} may not be "
+                f"cached locally.",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"rly: npx fallback did not complete within {timeout_s}s. "
+                "Set RLY_TIMEOUT_SECONDS higher, or remove RLY_FORCE_NPX to "
+                "use the bundled binary.",
+                file=sys.stderr,
+            )
+        return 124
+    except KeyboardInterrupt:
+        return 130
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+
+    # Emergency / backward-compat path. Use only if the bundled binary is
+    # broken on this platform or missing (sdist install). Honored BEFORE
+    # any binary work so callers on Alpine/musl (where the wheel falls
+    # back to sdist) still have an escape hatch when Node is on PATH.
+    if os.environ.get("RLY_FORCE_NPX") == "1":
+        return _run_npx_fallback(args)
+
+    binary_path = _resolve_bundled_binary()
+    if binary_path is None:
+        print(_no_binary_error(), file=sys.stderr)
+        return 1
+
+    # exec the binary. subprocess.run on Windows + Unix gives clean
+    # signal / exit-code semantics. RLY_TIMEOUT_SECONDS opt-in carries
+    # over from W3; bundled-binary exec is local + fast, but callers may
+    # bound it (e.g. CI watchdogs).
+    timeout_s = _resolve_timeout(args)
+    try:
+        completed = subprocess.run(
+            [binary_path, *args], check=False, timeout=timeout_s
+        )
+        return completed.returncode
+    except subprocess.TimeoutExpired:
+        print(
+            f"rly: command did not complete within {timeout_s}s. "
+            "Set RLY_TIMEOUT_SECONDS higher.",
+            file=sys.stderr,
+        )
+        return 124
+    except FileNotFoundError:
+        # Binary was resolvable as a path but exec failed (binary deleted
+        # between resolve and exec — rare race; or the wheel's binary is
+        # for a different libc and the dynamic loader rejected it).
+        print(
+            f"rly: bundled binary at {binary_path} could not be executed. "
+            "The wheel may be for a different platform than the host. "
+            "Reinstall with `pipx install --force rly`.",
+            file=sys.stderr,
+        )
+        return 127
+    except KeyboardInterrupt:
+        return 130

rly-0.2.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: rly
+Version: 0.2.0
+Summary: PyPI launcher for the ReplyLayer CLI
+Project-URL: Homepage, https://replylayer.ai
+Project-URL: Repository, https://github.com/replylayer/ReplyLayer
+Project-URL: Issues, https://github.com/replylayer/ReplyLayer/issues
+Author: ReplyLayer
+License-Expression: MIT
+Keywords: agent,ai,cli,email,mailbox,replylayer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: Email
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build==1.2.2.post1; extra == 'dev'
+Requires-Dist: pytest==8.3.4; extra == 'dev'
+Requires-Dist: wheel==0.45.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# rly
+
+`rly` is the PyPI launcher for the ReplyLayer CLI.
+
+```bash
+pipx install rly
+rly --help
+```
+
+On Debian and Ubuntu systems that enforce PEP 668, plain `pip install rly`
+may fail with `externally-managed-environment`. Use `pipx install rly` for a
+global CLI install, or install inside a virtual environment:
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+pip install rly
+```
+
+The installed `rly` command delegates to the official npm package
+`replylayer`, pinned exactly to the matching launcher version (see
+[Strict pin policy](#strict-pin-policy) below).
+
+## Requirements
+
+- Python 3.10+
+- Node.js 22+ with npm/npx on `PATH`
+- pipx for the recommended global install path
+
+## Examples
+
+```bash
+rly auth login
+rly mailbox list
+rly inbox list --mailbox support-bot
+```
+
+For full CLI documentation, see the ReplyLayer repository:
+https://github.com/replylayer/ReplyLayer
+
+## Environment variables
+
+### `RLY_TIMEOUT_SECONDS`
+
+Opt-in subprocess timeout, in seconds. When set, every `rly` invocation is
+bounded by `subprocess.run(..., timeout=RLY_TIMEOUT_SECONDS)`; if the
+underlying `npx` process does not exit in time the launcher prints a
+diagnostic to stderr and exits with code `124`.
+
+By default there is no timeout, with one narrow exception: the help and
+version short-circuits (`--help`, `-h`, `--version`, `-V`) carry a built-in
+10-second timeout. Those commands should never need to touch the network
+beyond an initial registry resolve; bounding them lets you diagnose a
+restricted-network sandbox without affecting legitimate long-poll commands
+like `rly inbox wait --timeout 60`.
+
+```bash
+RLY_TIMEOUT_SECONDS=30 rly inbox list --mailbox support-bot
+```
+
+Set the value high enough to cover the slowest command you reasonably
+expect. Setting it to a non-integer string is treated as "no timeout"
+(graceful fallback rather than a launcher crash).
+
+### `RLY_OFFLINE`
+
+Set `RLY_OFFLINE=1` to force `npx` to resolve `replylayer` from the local
+cache only. The launcher passes both `--offline` on the command line **and**
+`npm_config_offline=true` in the subprocess environment (belt-and-suspenders;
+`--prefer-offline` is NOT a no-network guarantee).
+
+If the pinned `replylayer` version isn't cached locally, `npx` exits fast
+with its own non-zero exit code (typically `1` with `ENOTCACHED`); the
+wrapper passes that exit code through verbatim — it does NOT normalize it
+to `124`. Exit code `124` is reserved for the wrapper's own timeout branch.
+
+```bash
+# Populate the cache once, online:
+rly --version
+# Subsequent calls can run offline:
+RLY_OFFLINE=1 rly --version
+```
+
+`RLY_OFFLINE=1` is useful in network-restricted CI sandboxes, air-gapped
+deployments, or any environment where you want a hard guarantee that the
+launcher will not reach out to the npm registry.
+
+## Strict pin policy
+
+`rly@X.Y.Z` always resolves `replylayer@X.Y.Z` exactly — there is no
+`@latest` resolution and no semver range. The launcher computes the pinned
+package string at runtime via `importlib.metadata.version('rly')`, so the
+two artifacts always move together.
+
+This means:
+
+- A published `rly@X.Y.Z` cannot ride a later patch-level `replylayer`
+  release; both packages must be republished together. The matched-pair
+  release runbook lives at `docs/runbooks/cli-release.md` in the
+  ReplyLayer repository.
+- Source installs from the repository between a launcher-only PR and the
+  paired version bump are intentionally unsupported. Use `pipx install rly`
+  (PyPI) or `npm install -g replylayer` (npm) as the supported install
+  paths.

rly-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+rly/__init__.py,sha256=5FlJ4Z6BHHJ3nif_IiZ5G-hdpUrdA9ZvV1erUDV2hNU,119
+rly/__main__.py,sha256=h1QpgvR08tO6TfQHuySKKgQiQVXVIoQRKLEx5sVht_M,67
+rly/cli.py,sha256=V8PJDwg_FgaMR4fcyh5cRsvzHdYkZfn70UpTkDjEYWc,8178
+rly/_binaries/.gitkeep,sha256=up7lTij0VRXRaKJ2tBBLOYP9RwySj9uovZ-sKttm2Bk,419
+rly/_binaries/replylayer.exe,sha256=ic9ryP5Zf4MGH8i8nMN1KCaI8a4g64lAShV3N4zg6yM,80875520
+rly-0.2.0.dist-info/METADATA,sha256=mi4WiO0CNMtnwsHG15hiWkKxh4lYEaEuRGGCfD_IWVI,4450
+rly-0.2.0.dist-info/WHEEL,sha256=fip2IBhkkNvH-S_Xh3PV94_XVqHJB1nn9gTAcldDBj4,94
+rly-0.2.0.dist-info/entry_points.txt,sha256=WTGfCCCFuHNRnhfvvP2y59WS2siy5SzSmXiaQ8t5sPQ,37
+rly-0.2.0.dist-info/RECORD,,

rly-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

rly-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rly = rly.cli:main