@runinfra/cli 0.1.1 → 0.2.2

package/README.md

@@ -3,9 +3,6 @@
 Sign in from your terminal and pull the optimized model packages your workspace
 owns.
 
-Node 20 or newer. **Zero runtime dependencies** by design, so it installs
-quickly and runs cleanly inside a slim container or a locked-down host.
-
 ```console
 $ npm install -g @runinfra/cli
 $ runinfra login
@@ -16,11 +13,145 @@ Replace `<slug>` with the slug shown on your package's page under
 **Optimized models** on runinfra.ai, for example
 `qwen3-6-27b-fp8cd-v3-mlponly-h100-vllm`.
 
+---
+
+## Install
+
+<!-- Release note for the next editor: when the installer and the wheel are
+     actually published, the standalone line becomes the lead command in the
+     block above and its Status cell becomes "Live". Do not promote a row
+     before fetching its artifact and installing from it: the Status column
+     is the only thing standing between a reader and a command that 404s. -->
+
+Run the npm line above if the machine already has Node 20 or newer. It is the
+only channel published today.
+
+Two more channels are on the way, because these kits get pulled onto GPU hosts
+and a GPU host often has Python but no Node:
+
+| Channel | Command | Reach for it when | Status |
+| --- | --- | --- | --- |
+| Standalone | `curl -fsSL https://raw.githubusercontent.com/RightNow-AI/runinfra-cli/main/install.sh \| sh` | The box is bare. No Node, no Python, the download brings its own runtime. | Not published yet |
+| Python | `pip install runinfra-cli` | The machine already lives in Python. | Not published yet |
+| Node | `npm install -g @runinfra/cli` | The machine already lives in Node 20 or newer. | **Live, 0.1.1** |
+
+Only the npm row works right now. Checked on 2026-07-27:
+`pip index versions runinfra-cli` answers "No matching distribution found",
+and the installer URL returns 404 because the script is not on the release
+repository's main branch yet. Both are written down with their real commands
+rather than left out, so the release that publishes them only has to flip a
+Status cell, and so a reader can tell today what works from what does not.
+
+All three publish at the same version, **0.1.1**, and put the same `runinfra`
+command on PATH: the two new channels repackage the client that is already on
+npm rather than changing it. So `runinfra --version` reads the same however it
+arrived, and every command in this document behaves identically. What differs
+is only what has to be on the machine first:
+
+- **Standalone and Python** install one compiled executable with the runtime
+  inside it. Nothing else is required, which is the whole point on a host you
+  did not build. Note the distribution name: `pip install runinfra-cli` is
+  this tool, `pip install runinfra` is the inference SDK, a different product
+  for calling an endpoint from your code.
+- **npm** installs the same program as JavaScript and runs it on the Node you
+  already have. It has **zero runtime dependencies** by design, so it installs
+  quickly and runs cleanly inside a slim container or a locked-down host.
+
+Rather not install anything globally? The npm channel also runs through npx,
+for example `npx @runinfra/cli pull <slug>`.
+
 If your registry cannot find `@runinfra/cli`, the release has not reached it
 yet. Run the CLI from a checkout instead, see [Development](#development).
 
 ---
 
+## Verifying a release
+
+Every release publishes `SHA256SUMS`, which lists the sha256 of each binary,
+and `SHA256SUMS.sig`, an Ed25519 signature over that file.
+
+`install.sh` checks both for you. It carries the public key **inside the
+script** rather than fetching it, because a key downloaded from the same host
+as the binary proves nothing: whoever can replace one can replace the other and
+serve a matching pair. It verifies the signature before it reads a single hash
+out of `SHA256SUMS`, and a bad signature ends the install rather than printing
+a warning.
+
+A **missing** signature ends the install too, when the artifacts came from a
+release. An attacker who can serve you a swapped binary can also delete the
+signature that would expose it, so a check that disappears on request is not a
+check. If you are deliberately mirroring a release, or installing one published
+before the signing key existed, `RUNINFRA_ALLOW_UNSIGNED=1` skips it and says
+so, and artifacts taken from your own `--base-url` are never held to this rule.
+
+Being unable to **perform** the check is the one case that stays a warning. If
+the host has no `openssl`, or none that can do Ed25519, `install.sh` says so on
+one line, names that exact reason, and continues on the checksum alone.
+Refusing to install on a minimal container would cost more than it buys, and
+the checksum still refuses a bad download. On macOS it looks past the LibreSSL
+at `/usr/bin/openssl`, which cannot do the job, and tries the Homebrew
+`openssl@3` locations before it gives up.
+
+`install.ps1` does not check the signature. Windows PowerShell 5.1 has no
+Ed25519 and .NET only gained one in 8, so it verifies the checksum, prints the
+command below, and tells you which check it skipped rather than letting you
+assume both ran.
+
+To check a release by hand, save this as `runinfra-release.pub`:
+
+```
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAYkEJIc7GfRAHAvUXcY/jrtnwFj53XZNDoXE6cAkOxYk=
+-----END PUBLIC KEY-----
+```
+
+Its fingerprint is sha256 over the raw 32 byte key, and you can derive it from
+the file you just saved rather than taking this line on trust:
+
+```console
+$ openssl pkey -pubin -in runinfra-release.pub -outform DER | tail -c 32 | sha256sum
+5b2c8f637c0cd00a61ec6f126e5a9493c022ef1ea5be70fdd3ef4adf55801532
+```
+
+Then, in the directory holding the downloaded files:
+
+```console
+$ openssl pkeyutl -verify -pubin -inkey runinfra-release.pub -rawin -in SHA256SUMS -sigfile SHA256SUMS.sig
+Signature Verified Successfully
+
+$ sha256sum --ignore-missing -c SHA256SUMS
+runinfra-linux-x64: OK
+```
+
+Run them in that order. The signature is what makes the checksum worth
+checking: `SHA256SUMS` arrives from the same place as the binary, so anyone who
+can swap the binary can swap its recorded hash to match. Verify the signature
+first, then let the verified `SHA256SUMS` speak for the bytes.
+
+Two things that are a failed check rather than a bad file. If the signature is
+published base64 encoded rather than as 64 raw bytes, decode it first and point
+`-sigfile` at the result, `base64 -d SHA256SUMS.sig > SHA256SUMS.sig.raw`, with
+`-D` instead of `-d` on macOS. And
+`-rawin` needs OpenSSL 1.1.1 or newer: the `openssl` on a stock macOS is
+LibreSSL, whose `pkeyutl` has no `-rawin` at all, so it answers with a usage
+error rather than a verdict. Read that as "not checked", not as "bad", and
+install OpenSSL through Homebrew if you want the real answer.
+
+### What a good signature proves
+
+It proves the RunInfra release pipeline signed that file with the private half
+of the key above, and that nothing has altered it since.
+
+It does **not** prove that pipeline was not subverted. The signing key lives in
+CI, so anyone who could steal the release token or edit the release workflow
+could also reach the key and sign whatever they wanted. What this closes is a
+release asset altered after publication, and a mirror or CDN serving something
+other than what was published. Both are real attacks and both are worth
+closing. Neither is the same thing as the download being tamper proof, and we
+do not claim it is.
+
+---
+
 ## What the CLI never does
 
 - **It never sees your password.** Sign-in happens in your browser, in your

package/dist/http.js

@@ -2,6 +2,7 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { isLoopbackHostname } from "./endpoints.js";
 import { CliError } from "./errors.js";
+import { CLI_LATEST_VERSION_HEADER, recordLatest } from "./update-notice.js";
 import { userAgent } from "./version.js";
 export const DEFAULT_IDLE_TIMEOUT_MS = 30_000;
 export const DEFAULT_MAX_BODY_BYTES = 2 * 1024 * 1024;
@@ -13,6 +14,7 @@ function normalizeHeaders(message) {
             continue;
         out[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
     }
+    recordLatest(out[CLI_LATEST_VERSION_HEADER]);
     return out;
 }
 function networkError(url, cause) {
@@ -45,7 +47,9 @@ async function dispatch(options) {
     const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
     let currentUrl = options.url;
     let method = options.method;
-    let body = options.json === undefined ? null : Buffer.from(JSON.stringify(options.json), "utf8");
+    let body = options.json === undefined
+        ? null
+        : Buffer.from(JSON.stringify(options.json), "utf8");
     const originalOrigin = new URL(options.url).origin;
     for (let hop = 0; hop <= maxRedirects; hop += 1) {
         const parsed = new URL(currentUrl);
@@ -82,7 +86,11 @@ async function dispatch(options) {
         });
         const status = message.statusCode ?? 0;
         const location = message.headers.location;
-        const isRedirect = (status === 301 || status === 302 || status === 303 || status === 307 || status === 308) &&
+        const isRedirect = (status === 301 ||
+            status === 302 ||
+            status === 303 ||
+            status === 307 ||
+            status === 308) &&
             typeof location === "string";
         if (!isRedirect) {
             return { message, finalUrl: currentUrl };
@@ -95,7 +103,8 @@ async function dispatch(options) {
         if (next.protocol === "http:" && !isLoopbackHostname(next.hostname)) {
             throw new CliError("network", `${parsed.host} redirected to a plaintext URL off this machine (${next.protocol}//${next.host}).`, "This is not something the CLI can safely follow. Report it to support.");
         }
-        if (status === 303 || ((status === 301 || status === 302) && method !== "HEAD")) {
+        if (status === 303 ||
+            ((status === 301 || status === 302) && method !== "HEAD")) {
             method = "GET";
             body = null;
         }
@@ -122,8 +131,13 @@ async function bufferBody(message, url, maxBytes) {
 }
 export async function requestRaw(options) {
     const { message, finalUrl } = await dispatch(options);
+    const headers = normalizeHeaders(message);
     const body = await bufferBody(message, finalUrl, options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES);
-    return { status: message.statusCode ?? 0, headers: normalizeHeaders(message), body };
+    return {
+        status: message.statusCode ?? 0,
+        headers,
+        body,
+    };
 }
 export async function requestJson(options) {
     const raw = await requestRaw(options);
@@ -145,18 +159,25 @@ export async function headResource(url, options = {}) {
     const { message } = await dispatch({
         method: "HEAD",
         url,
-        ...(options.idleTimeoutMs === undefined ? {} : { idleTimeoutMs: options.idleTimeoutMs }),
+        ...(options.idleTimeoutMs === undefined
+            ? {}
+            : { idleTimeoutMs: options.idleTimeoutMs }),
         ...(options.signal ? { signal: options.signal } : {}),
     });
     message.resume();
-    return { status: message.statusCode ?? 0, headers: normalizeHeaders(message) };
+    return {
+        status: message.statusCode ?? 0,
+        headers: normalizeHeaders(message),
+    };
 }
 export async function streamRange(request) {
     const { message, finalUrl } = await dispatch({
         method: "GET",
         url: request.url,
         headers: { range: `bytes=${request.start}-${request.endInclusive}` },
-        ...(request.idleTimeoutMs === undefined ? {} : { idleTimeoutMs: request.idleTimeoutMs }),
+        ...(request.idleTimeoutMs === undefined
+            ? {}
+            : { idleTimeoutMs: request.idleTimeoutMs }),
         ...(request.signal ? { signal: request.signal } : {}),
     });
     const status = message.statusCode ?? 0;
@@ -172,7 +193,9 @@ export async function streamWhole(request) {
     const { message, finalUrl } = await dispatch({
         method: "GET",
         url: request.url,
-        ...(request.idleTimeoutMs === undefined ? {} : { idleTimeoutMs: request.idleTimeoutMs }),
+        ...(request.idleTimeoutMs === undefined
+            ? {}
+            : { idleTimeoutMs: request.idleTimeoutMs }),
         ...(request.signal ? { signal: request.signal } : {}),
     });
     const status = message.statusCode ?? 0;

package/dist/main.js

@@ -6,7 +6,8 @@ import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { createOutput } from "./output.js";
 import { pull } from "./pull.js";
-import { CLI_NAME, CLI_VERSION, isSupportedNodeVersion, MINIMUM_NODE_MAJOR } from "./version.js";
+import { maybePrintUpdateNotice } from "./update-notice.js";
+import { CLI_NAME, CLI_VERSION, isSupportedNodeVersion, MINIMUM_NODE_MAJOR, } from "./version.js";
 import { whoami } from "./whoami.js";
 export async function run(argv, options = {}) {
     const output = options.output ?? createOutput();
@@ -35,22 +36,32 @@ export async function run(argv, options = {}) {
             ...(options.env ? { env: options.env } : {}),
             ...(options.platform ? { platform: options.platform } : {}),
         });
+        let exitCode;
         switch (parsed.args.command) {
             case "login":
-                return await login(context, { device: parsed.args.device });
+                exitCode = await login(context, { device: parsed.args.device });
+                break;
             case "logout":
-                return await logout(context);
+                exitCode = await logout(context);
+                break;
             case "whoami":
-                return await whoami(context);
+                exitCode = await whoami(context);
+                break;
             case "pull": {
                 const slug = parsed.args.slug;
                 if (slug === null) {
                     output.error("runinfra pull needs a package slug.");
                     return 2;
                 }
-                return await pull(context, { slug, out: parsed.args.out, concurrency: parsed.args.concurrency }, signal);
+                exitCode = await pull(context, { slug, out: parsed.args.out, concurrency: parsed.args.concurrency }, signal);
+                break;
             }
         }
+        await maybePrintUpdateNotice(output, {
+            env: options.env ?? process.env,
+            platform: options.platform ?? process.platform,
+        });
+        return exitCode;
     }
     catch (error) {
         output.endStatus();
@@ -61,7 +72,12 @@ export async function run(argv, options = {}) {
         if (described.code === "unexpected") {
             output.detail("This is a bug in the CLI. Report it with the command you ran and this message.");
         }
-        return exitCodeFor(error);
+        const exitCode = exitCodeFor(error);
+        await maybePrintUpdateNotice(output, {
+            env: options.env ?? process.env,
+            platform: options.platform ?? process.platform,
+        });
+        return exitCode;
     }
 }
 function neverAborted() {

package/dist/update-notice.js

@@ -0,0 +1,216 @@
+import { chmod, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { credentialLocation } from "./paths.js";
+import { CLI_VERSION } from "./version.js";
+export const CLI_LATEST_VERSION_HEADER = "x-runinfra-cli-latest";
+export const UPDATE_CHECK_FILE_NAME = "update-check.json";
+const NOTICE_INTERVAL_MS = 24 * 60 * 60 * 1_000;
+const PYPI_CHANNEL = "pypi";
+const POSIX_INSTALLER = "curl -fsSL https://raw.githubusercontent.com/RightNow-AI/runinfra-cli/main/install.sh | sh";
+const WINDOWS_INSTALLER = "irm https://raw.githubusercontent.com/RightNow-AI/runinfra-cli/main/install.ps1 | iex";
+let latestSeen = null;
+function parseVersion(version) {
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u.exec(version);
+    if (!match)
+        return null;
+    const core = [match[1], match[2], match[3]].map((part) => Number.parseInt(part ?? "", 10));
+    if (core.some((part) => !Number.isSafeInteger(part) || part < 0))
+        return null;
+    const rawPrerelease = match[4];
+    const prerelease = rawPrerelease?.split(".") ?? null;
+    if (prerelease?.some((part) => part.length === 0 ||
+        !/^[0-9A-Za-z-]+$/u.test(part) ||
+        (/^\d+$/u.test(part) && part.length > 1 && part.startsWith("0")))) {
+        return null;
+    }
+    return {
+        core: [core[0] ?? 0, core[1] ?? 0, core[2] ?? 0],
+        prerelease,
+    };
+}
+function comparePrerelease(a, b) {
+    if (a === null && b === null)
+        return 0;
+    if (a === null)
+        return 1;
+    if (b === null)
+        return -1;
+    const length = Math.max(a.length, b.length);
+    for (let index = 0; index < length; index += 1) {
+        const aPart = a[index];
+        const bPart = b[index];
+        if (aPart === undefined)
+            return -1;
+        if (bPart === undefined)
+            return 1;
+        if (aPart === bPart)
+            continue;
+        const aNumeric = /^\d+$/u.test(aPart);
+        const bNumeric = /^\d+$/u.test(bPart);
+        if (aNumeric && bNumeric) {
+            if (aPart.length !== bPart.length) {
+                return aPart.length < bPart.length ? -1 : 1;
+            }
+            return aPart < bPart ? -1 : 1;
+        }
+        if (aNumeric !== bNumeric)
+            return aNumeric ? -1 : 1;
+        return aPart < bPart ? -1 : 1;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const parsedA = parseVersion(a);
+    const parsedB = parseVersion(b);
+    if (!parsedA || !parsedB)
+        return 0;
+    for (let index = 0; index < parsedA.core.length; index += 1) {
+        const aPart = parsedA.core[index] ?? 0;
+        const bPart = parsedB.core[index] ?? 0;
+        if (aPart === bPart)
+            continue;
+        return aPart < bPart ? -1 : 1;
+    }
+    return comparePrerelease(parsedA.prerelease, parsedB.prerelease);
+}
+export function recordLatest(version) {
+    if (version === undefined || parseVersion(version) === null)
+        return;
+    if (latestSeen === null || compareVersions(version, latestSeen) === 1) {
+        latestSeen = version;
+    }
+}
+export function __resetLatestForTest() {
+    latestSeen = null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseState(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(value))
+        return null;
+    if (typeof value.version !== "string" ||
+        parseVersion(value.version) === null) {
+        return null;
+    }
+    if (typeof value.lastNotifiedAt !== "number" ||
+        !Number.isSafeInteger(value.lastNotifiedAt) ||
+        value.lastNotifiedAt < 0) {
+        return null;
+    }
+    return { version: value.version, lastNotifiedAt: value.lastNotifiedAt };
+}
+async function readState(file) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { kind: "missing" };
+        }
+        throw error;
+    }
+    const state = parseState(raw);
+    return state ? { kind: "valid", state } : { kind: "invalid" };
+}
+function shouldNotify(latest, state, nowMs) {
+    if (compareVersions(latest, CLI_VERSION) !== 1)
+        return false;
+    if (state.kind === "invalid")
+        return false;
+    if (state.kind === "missing")
+        return true;
+    const alreadyNotified = compareVersions(state.state.version, latest);
+    if (alreadyNotified === 1)
+        return false;
+    if (alreadyNotified === -1)
+        return true;
+    return nowMs - state.state.lastNotifiedAt >= NOTICE_INTERVAL_MS;
+}
+function updateMessage(latest, env, platform, versions) {
+    if (env.RUNINFRA_DIST_CHANNEL === PYPI_CHANNEL) {
+        return `RunInfra CLI ${latest} is available. Upgrade: pip install --upgrade runinfra-cli`;
+    }
+    if (versions.bun !== undefined) {
+        const installer = platform === "win32" ? WINDOWS_INSTALLER : POSIX_INSTALLER;
+        return `RunInfra CLI ${latest} is available. Re-run the RunInfra standalone installer: ${installer}`;
+    }
+    return `RunInfra CLI ${latest} is available. Upgrade: npm install -g @runinfra/cli@latest`;
+}
+async function persistState(file, temp, state, platform) {
+    try {
+        await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        if (platform !== "win32")
+            await chmod(temp, 0o600);
+        await rename(temp, file);
+        if (platform !== "win32")
+            await chmod(file, 0o600);
+    }
+    catch (error) {
+        await rm(temp, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function releaseLock(lock, lockFile) {
+    if (lock === null)
+        return;
+    await lock.close().catch(() => undefined);
+    await rm(lockFile, { force: true }).catch(() => undefined);
+}
+async function printUpdateNotice(output, deps) {
+    const latest = latestSeen;
+    if (latest === null || compareVersions(latest, CLI_VERSION) !== 1)
+        return;
+    const env = deps.env ?? process.env;
+    const platform = deps.platform ?? process.platform;
+    const location = credentialLocation({
+        platform,
+        env,
+        homeDir: deps.homeDir ?? homedir(),
+    });
+    const file = join(location.dir, UPDATE_CHECK_FILE_NAME);
+    const temp = `${file}.${process.pid}.tmp`;
+    const lockFile = `${file}.lock`;
+    const nowMs = (deps.now ?? Date.now)();
+    if (!Number.isSafeInteger(nowMs) || nowMs < 0)
+        return;
+    await mkdir(location.dir, {
+        recursive: true,
+        ...(platform === "win32" ? {} : { mode: 0o700 }),
+    });
+    if (platform !== "win32")
+        await chmod(location.dir, 0o700);
+    let lock = null;
+    try {
+        lock = await open(lockFile, "wx", 0o600);
+        if (platform !== "win32")
+            await chmod(lockFile, 0o600);
+        const state = await readState(file);
+        if (!shouldNotify(latest, state, nowMs))
+            return;
+        await persistState(file, temp, { version: latest, lastNotifiedAt: nowMs }, platform);
+        output.info(updateMessage(latest, env, platform, deps.versions ?? process.versions));
+    }
+    finally {
+        await releaseLock(lock, lockFile);
+    }
+}
+export async function maybePrintUpdateNotice(output, deps = {}) {
+    try {
+        await printUpdateNotice(output, deps);
+    }
+    catch {
+    }
+}

package/dist/version.js

@@ -1,6 +1,6 @@
 export const CLI_NAME = "runinfra";
 export const CLI_PACKAGE = "@runinfra/cli";
-export const CLI_VERSION = "0.1.1";
+export const CLI_VERSION = "0.2.2";
 export const CLI_CLIENT_ID = "runinfra-cli";
 export const MINIMUM_NODE_MAJOR = 20;
 export function isSupportedNodeVersion(version) {

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@runinfra/cli",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "RunInfra CLI: browser-approved sign-in and resumable downloads for optimized model packages",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://runinfra.ai/catalog",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RightNow-AI/runinfra-cli.git"
+  },
   "bugs": {
     "url": "https://runinfra.ai/contact"
   },