runinfra-cli 0.2.0__py3-none-win_amd64.whl

runinfra_cli/__init__.py

@@ -0,0 +1,211 @@
+"""Launcher for the RunInfra CLI.
+
+`pip install runinfra-cli` puts a `runinfra` command on PATH. That command is
+this module, and its whole job is to hand control to the program shipped
+inside the wheel and then stop existing. Nothing about signing in, about
+entitlement, or about downloading a package lives here. This file only has to
+get out of the way cleanly.
+
+Getting out of the way cleanly is the entire design constraint. `runinfra`
+gets run from CI jobs and provisioning scripts that branch on its exit code:
+2 for bad usage, 3 for a sign in problem, 4 when the workspace does not own
+the package, 5 for a transport failure, 6 for an integrity failure, 7 for a
+local disk problem, and 130 when someone pressed Ctrl-C. A launcher that
+turned any of those into a generic 1 would quietly break every one of those
+scripts, and it would break them in the worst way: the caller would retry a
+failure that will never succeed, or give up on one that would have.
+
+So on Unix this process calls execv and ceases to exist, which makes exit
+code and signal fidelity not a feature to maintain but a thing that cannot go
+wrong. Windows has no execv with those semantics, so there the launcher stays
+alive as a thin parent, refuses to answer Ctrl-C itself, and returns exactly
+the code its child returned.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import NoReturn
+
+__all__ = ["__version__", "binary_path", "main"]
+
+# One of four copies of this string. The others are cli/package.json,
+# cli/src/version.ts and cli/pypi/pyproject.toml. build_wheels.py compares all
+# four and refuses to build when they disagree, so this literal cannot drift
+# on its own.
+__version__ = "0.2.0"
+
+# Where the wheel keeps the program, relative to this file. The leading
+# underscore marks it as ours: it is not an import package and nothing outside
+# this module should reach into it.
+_PROGRAM_DIR = "_bin"
+
+_SUPPORT_URL = "https://runinfra.ai/contact"
+
+# Matches the CLI's own code for "this machine cannot run the command", so a
+# script that already branches on 2 keeps working when the failure happens one
+# layer out here instead of inside the program.
+_EXIT_UNSUPPORTED_RUNTIME = 2
+
+
+def binary_path() -> Path:
+    """Return the absolute path of the program this installation carries.
+
+    There is no platform detection to do at run time. pip already did it: it
+    chose one wheel out of the release using the wheel's platform tag, and
+    that wheel carries exactly one program. All that is left is the file name
+    convention of the operating system running right now.
+    """
+    name = "runinfra.exe" if os.name == "nt" else "runinfra"
+    return Path(__file__).resolve().parent / _PROGRAM_DIR / name
+
+
+def main() -> NoReturn:
+    """Run the CLI with this process's arguments, and never return."""
+    program = binary_path()
+    if not program.is_file():
+        _fail_no_program_for_platform(program)
+
+    argv = [str(program), *sys.argv[1:]]
+
+    # The embedded program cannot otherwise know which published channel owns
+    # its upgrade command. execv and subprocess.run both inherit this value.
+    os.environ["RUNINFRA_DIST_CHANNEL"] = "pypi"
+
+    if os.name == "nt":
+        raise SystemExit(_run_on_windows(argv))
+    _exec_on_posix(program, argv)
+
+
+def _exec_on_posix(program: Path, argv: list[str]) -> NoReturn:
+    """Replace this process with the CLI.
+
+    After execv succeeds there is no launcher left, so the process id, the
+    controlling terminal, every signal and the exit code all belong to the
+    CLI itself. Ctrl-C reaches it directly, which is what lets it finish the
+    write it was in the middle of and exit 130 with a resumable download on
+    disk.
+
+    Nothing on this path may install a signal handler first. A disposition of
+    "ignore" survives execv, so ignoring Ctrl-C here, which is the correct
+    thing to do on the Windows path below, would leave the CLI permanently
+    unable to see it.
+    """
+    for attempt in (1, 2):
+        try:
+            os.execv(str(program), argv)
+        except PermissionError:
+            # Wheels record the execute bit and pip restores it, but a wheel
+            # unpacked by hand with a tool that does not carry file modes
+            # arrives without it. That is one syscall to repair and a support
+            # round trip to diagnose, so repair it once and try again.
+            if attempt == 1 and _restore_execute_bit(program):
+                continue
+            _fail_not_executable(program)
+        except OSError as error:
+            _fail_to_launch(program, error)
+
+    _fail_not_executable(program)
+
+
+def _run_on_windows(argv: list[str]) -> int:
+    """Run the CLI as a child process and return its exit code unchanged."""
+    import signal
+    import subprocess
+
+    # On Windows, Ctrl-C is delivered to every process attached to the
+    # console, this launcher included. If the launcher answered it, Python
+    # would raise KeyboardInterrupt here and the shell would see the
+    # launcher's exit code instead of the 130 the CLI returns once it has
+    # finished its current write. Declining to answer leaves the CLI as the
+    # only process that does, so its code is the one that survives.
+    try:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+    except (OSError, ValueError):
+        # Only the main thread is allowed to install a handler. Off it, the
+        # CLI still receives and handles its own Ctrl-C exactly as before; the
+        # only thing lost is the guarantee about whose exit code wins a race
+        # that almost never happens. Not worth refusing to run over.
+        pass
+
+    try:
+        completed = subprocess.run(argv)
+    except OSError as error:
+        _fail_to_launch(Path(argv[0]), error)
+    return completed.returncode
+
+
+def _restore_execute_bit(program: Path) -> bool:
+    """Put the execute bit back, reporting whether it is set afterwards.
+
+    Returns False rather than raising when the file system refuses, for
+    example on a read only installation, so the caller can say what is wrong
+    in one sentence instead of unwinding a traceback at the user.
+    """
+    try:
+        program.chmod(program.stat().st_mode | 0o111)
+        return bool(program.stat().st_mode & 0o111)
+    except OSError:
+        return False
+
+
+def _fail_no_program_for_platform(program: Path) -> NoReturn:
+    import platform
+
+    _die(
+        _EXIT_UNSUPPORTED_RUNTIME,
+        "this installation does not include a program for your platform.",
+        "System: {0}, machine: {1}".format(platform.system(), platform.machine()),
+        "Expected it at: {0}".format(program),
+        "",
+        "Reinstall so pip can select the matching build:",
+        "  pip install --force-reinstall runinfra-cli",
+        "",
+        "If pip reports no matching distribution, this platform is not",
+        "supported yet. Tell us which one you need: {0}".format(_SUPPORT_URL),
+    )
+
+
+def _fail_not_executable(program: Path) -> NoReturn:
+    _die(
+        _EXIT_UNSUPPORTED_RUNTIME,
+        "the program is installed but this machine will not run it.",
+        "Program: {0}".format(program),
+        "",
+        "Either the file lost its execute permission, or it sits on a volume",
+        "mounted without permission to execute anything on it.",
+        "",
+        "  chmod +x {0}".format(program),
+        "  pip install --force-reinstall runinfra-cli",
+        "",
+        "If neither helps: {0}".format(_SUPPORT_URL),
+    )
+
+
+def _fail_to_launch(program: Path, error: OSError) -> NoReturn:
+    reason = error.strerror or str(error)
+    _die(
+        _EXIT_UNSUPPORTED_RUNTIME,
+        "could not start the program: {0}".format(reason),
+        "Program: {0}".format(program),
+        "",
+        "Reinstalling replaces the file with a known good copy:",
+        "  pip install --force-reinstall runinfra-cli",
+        "",
+        "If it keeps happening: {0}".format(_SUPPORT_URL),
+    )
+
+
+def _die(exit_code: int, message: str, *detail: str) -> NoReturn:
+    """Report a launcher failure the way the CLI itself reports failures.
+
+    One sentence naming what went wrong, then indented lines that name the
+    next thing the reader can actually do. Never a traceback: a traceback
+    tells the reader about this file, and this file is not their problem.
+    """
+    sys.stderr.write("runinfra: {0}\n".format(message))
+    for line in detail:
+        sys.stderr.write("  {0}\n".format(line) if line else "\n")
+    raise SystemExit(exit_code)

runinfra_cli/__main__.py

@@ -0,0 +1,18 @@
+"""`python -m runinfra_cli`, which does exactly what `runinfra` does.
+
+Worth shipping because the two most common places these packages get pulled,
+containers and locked down GPU hosts, are also the two places where a virtual
+environment's scripts directory is most often missing from PATH. When that
+happens `runinfra` is "command not found" even though the install succeeded,
+and the module form is the answer that always works.
+
+It is a second door into the same room. All of the behaviour, including the
+exit codes, lives in __init__.py.
+"""
+
+from __future__ import annotations
+
+from . import main
+
+if __name__ == "__main__":
+    main()

runinfra_cli-0.2.0.dist-info/LICENSE

@@ -0,0 +1,48 @@
+RunInfra CLI License
+
+Copyright (c) 2026 RightNow AI. All rights reserved.
+
+1. LICENSE GRANT
+
+RightNow AI grants you a non-exclusive, non-transferable, revocable license
+to install and use this software ("the CLI") for the purpose of accessing
+the RunInfra service and downloading model packages your workspace is
+entitled to.
+
+2. RESTRICTIONS
+
+You may not redistribute, sell, sublicense or publish the CLI or any part of
+it. You may not modify the CLI and distribute the result. You may not remove
+or alter this notice.
+
+These restrictions apply to the CLI itself. They do NOT apply to the model
+packages the CLI downloads: each package carries its own license, stated on
+its product page and included in its kit, and that license governs your use
+of that package.
+
+3. NO WARRANTY
+
+THE CLI IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+The CLI writes large files to disk and transfers large amounts of data over
+your network. You are responsible for available disk space, for any metered
+bandwidth costs your provider charges, and for where you choose to store
+downloaded packages.
+
+4. LIMITATION OF LIABILITY
+
+IN NO EVENT SHALL RIGHTNOW AI BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE CLI OR THE USE OR OTHER DEALINGS IN THE CLI.
+
+5. TERMINATION
+
+This license ends if you breach it, or when your entitlement to the RunInfra
+service ends. On termination, stop using the CLI and delete it. Packages you
+have already lawfully downloaded remain governed by their own licenses.
+
+6. CONTACT
+
+https://runinfra.ai

runinfra_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.1
+Name: runinfra-cli
+Version: 0.2.0
+Summary: Sign in from your terminal and pull the optimized model packages your workspace owns
+Author: RightNow AI
+Project-URL: Homepage, https://runinfra.ai/catalog
+Project-URL: Support, https://runinfra.ai/contact
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.8
+Keywords: runinfra,cli,model,download,resumable,inference
+Description-Content-Type: text/markdown
+
+# runinfra-cli
+
+Sign in from your terminal and pull the optimized model packages your workspace
+owns.
+
+```console
+$ pip install runinfra-cli
+$ runinfra login
+$ runinfra pull <slug> --out ./models
+```
+
+Replace `<slug>` with the slug shown on your package's page under **Optimized
+models** on runinfra.ai.
+
+**No Node.js required.** This distribution carries a self contained program, so
+`pip install` is the only step. That is the point of publishing here: the hosts
+these packages get pulled onto usually have Python and often do not have Node.
+
+---
+
+## Which package do I want?
+
+There are two, they do different jobs, and installing the wrong one is the most
+common mistake we see.
+
+| Install | What it gives you | Use it when |
+| --- | --- | --- |
+| `pip install runinfra-cli` | The `runinfra` command | You want to sign in and download the packages your workspace bought |
+| `pip install runinfra` | The Python SDK, `import runinfra` | You want to call an optimized endpoint from your code |
+
+They are separate products on separate release cycles and they do not conflict.
+Installing both in the same environment is fine and supported.
+
+---
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `runinfra login [--device]` | Connects this terminal by having you approve it in a browser |
+| `runinfra pull <slug> [--out DIR] [--concurrency N]` | Downloads a package this workspace owns, resumable |
+| `runinfra logout` | Deletes the local credential and tells you where to revoke the key |
+| `runinfra whoami` | Shows what this machine has stored, and when its access expires |
+
+Run `runinfra --help` for the full grammar.
+
+### Signing in on a machine with no browser
+
+That is the normal case on a GPU host, and it is handled:
+
+```console
+$ runinfra login --device
+```
+
+The terminal prints a short code that you type into the approval page on
+whatever device does have a browser. The code never arrives inside a link. A
+link that shows up with the code already in it did not come from us.
+
+### Downloads resume
+
+Kits are large. If a transfer stops, for any reason including Ctrl-C, run the
+same `runinfra pull` command again and it continues from where it stopped
+rather than starting over.
+
+---
+
+## Exit codes
+
+These are a contract, not an implementation detail. Scripts branch on them, so
+they do not change without a major version.
+
+| Code | Meaning |
+| --- | --- |
+| 0 | Success |
+| 2 | Bad usage, or this machine cannot run the command |
+| 3 | Not signed in, denied, or expired |
+| 4 | The workspace does not own it |
+| 5 | Network or server failure |
+| 6 | Integrity failure, such as a checksum mismatch |
+| 7 | No disk space, or the destination is not writable |
+| 130 | Interrupted |
+
+The split matters in automation. A 5 is worth retrying. A 4 never will be.
+
+Installing through pip does not change any of this. The `runinfra` command
+installed here hands control straight to the program and returns its exit code
+untouched, including 130 from Ctrl-C.
+
+---
+
+## Supported platforms
+
+| Operating system | Processor |
+| --- | --- |
+| Linux (glibc 2.17 and newer) | x86-64, arm64 |
+| Linux (musl, such as Alpine) | x86-64, arm64 |
+| macOS 11 and newer | Apple silicon, Intel |
+| Windows 10 and newer | x86-64 |
+
+Python 3.8 or newer. There is nothing to compile and no build step, so the
+install is a download and an unpack.
+
+If `pip install runinfra-cli` reports that no matching distribution was found,
+your platform is not published yet. Tell us which one you need at
+<https://runinfra.ai/contact>.
+
+If the `runinfra` command is not found after a successful install, your
+environment's scripts directory is not on PATH. `python -m runinfra_cli` does
+the same thing and always works.
+
+---
+
+## What the CLI never does
+
+- **It never sees your password.** Sign in happens in your browser, in your
+  existing session. The CLI only ever holds an authorization code and, after
+  the exchange, the key that code bought.
+- **It never asks you to paste an API key.** Approving in the browser mints
+  one, the CLI writes it to a file only you can read, and revoking it in
+  Settings kills it.
+- **It never prints the key.** `whoami` and `logout` show a redacted form.
+- **The key it holds cannot spend money.** It opens exactly one door,
+  downloading a package your workspace already owns.
+
+Credentials are stored in `$XDG_CONFIG_HOME/runinfra/credentials.json` on Linux
+and macOS, and under `%LOCALAPPDATA%\runinfra\` on Windows. Set
+`RUNINFRA_CONFIG_DIR` to put them somewhere else.
+
+You can revoke this machine's access at any time from **Settings, API keys** on
+runinfra.ai.
+
+---
+
+## Licence and support
+
+Licensed for use with the RunInfra service. The full text ships in the package
+and is reproduced on the product pages. The packages this CLI downloads are
+covered by their own licences, stated on each package's page and included in
+each kit.
+
+Questions, or a platform you need: <https://runinfra.ai/contact>

runinfra_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+runinfra_cli/__init__.py,sha256=lH4x9RQtFq5FsLGycGFqK7V7qwFdDiGKlkNcTCJdI9U,8503
+runinfra_cli/__main__.py,sha256=0BIEeWO525qqpoKnnPPSxD3BV52YBuqjSP_x25V7Sfo,641
+runinfra_cli/_bin/runinfra.exe,sha256=Hzzi56VWKjenH820aoHxaVeONr3LKPhyGlVPdEQ-fvY,115764736
+runinfra_cli-0.2.0.dist-info/LICENSE,sha256=JewMbf_rFZalfeDZEHI5HgRb-fa7xGV80f5jI4WfwBU,1760
+runinfra_cli-0.2.0.dist-info/METADATA,sha256=7lj8hWLuSIGA1StcaKHtU--UivDSKMhHQLRoZTVCPZQ,5898
+runinfra_cli-0.2.0.dist-info/WHEEL,sha256=PkX5WTniyLpEndcRqICIkYlUb4YvTtiY1w37Yo6SWZ8,110
+runinfra_cli-0.2.0.dist-info/entry_points.txt,sha256=QQ1_VmipCFuqtpatnAsiF6IZ5sCV1NVKBbxgqgrRGJ4,47
+runinfra_cli-0.2.0.dist-info/RECORD,,

runinfra_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: runinfra build_wheels.py (0.2.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64

runinfra_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runinfra = runinfra_cli:main