rauta-ai 0.4.9 → 0.5.101

package/bin/rauta-ai.js

@@ -2,13 +2,24 @@
 // npx wrapper for the Rauta CLI (https://rauta.ai/docs).
 //
 // Package name is `rauta-ai` until npm clears unscoped `rauta` (similarity
-// filter vs ramda/auto/oauth). Prefer CDN artifacts named rauta-*; fall back
-// to infra-arena-* on both rauta.ai and rauta.ai during the interim
-// rename window. This shim downloads once, caches it, and execs with stdio
-// passed through.
+// filter vs ramda/auto/oauth). Prefer CDN artifacts named rauta-*; fall back to
+// infra-arena-* during the interim rename window. This shim downloads the
+// platform binary once, caches it, and execs it with stdio passed through.
+//
+// It verifies before it trusts, because the CDN's failure mode is not a 404.
+// When a path is missing, Pages answers 200 with the website's index.html --
+// the outage shape scripts/build-cli.sh documents. The previous version of this
+// file rejected only on statusCode !== 200, so it wrote that HTML into the
+// cache at mode 0755 and exec'd it. Every later run then failed ENOEXEC against
+// the cached page, and `rm -rf ~/.cache/rauta-ai` only downloaded the same HTML
+// again: an infinite loop with no way out. So the content type, the magic
+// bytes, the declared length and (once published) a sha256 are all checked
+// BEFORE the bytes are allowed near the cache, and a cache entry that is not an
+// executable image is discarded on sight rather than exec'd.
 'use strict';
 
 const { spawnSync } = require('node:child_process');
+const crypto = require('node:crypto');
 const fs = require('node:fs');
 const https = require('node:https');
 const os = require('node:os');
@@ -16,13 +27,49 @@ const path = require('node:path');
 
 const pkg = require('../package.json');
 const PRIMARY_BASE = process.env.RAUTA_CLI_BASE || process.env.INFRA_ARENA_CLI_BASE || 'https://rauta.ai/cli';
+// Currently identical to PRIMARY_BASE, so candidateUrls() dedupes down to the
+// versioned and unversioned paths of two artifact names -- four URLs, not
+// eight. It stays a separate constant so an env override of PRIMARY_BASE (an
+// internal mirror) still falls back to the public CDN.
 const FALLBACK_BASE = 'https://rauta.ai/cli';
 
-function fail(msg) {
-  process.stderr.write(`rauta-ai: ${msg}\n`);
+// Socket inactivity, not total transfer time: a slow link downloading 30MB must
+// not be cut off, but a proxy that accepts the connection and then says nothing
+// must not hang the terminal forever.
+const IDLE_TIMEOUT_MS = 60000;
+
+const DOCS = 'https://rauta.ai/docs';
+
+// The executable images we publish: linux (ELF) and darwin (Mach-O, thin or
+// universal). The check answers "is this a binary or an error page", not "is
+// this the right architecture" -- a wrong-arch binary is a build bug and shows
+// up as a clear ENOEXEC below, whereas an error page is the failure that used
+// to poison the cache.
+const EXECUTABLE_MAGIC = [
+  '7f454c46', // ELF
+  'feedface', // Mach-O 32, big-endian
+  'feedfacf', // Mach-O 64, big-endian
+  'cefaedfe', // Mach-O 32, little-endian
+  'cffaedfe', // Mach-O 64, little-endian
+  'cafebabe', // Mach-O universal
+  'bebafeca', // Mach-O universal, byte-swapped
+];
+
+/** Print one or more stderr lines prefixed with the tool name, then exit 1. */
+function fail() {
+  const lines = Array.prototype.slice.call(arguments);
+  process.stderr.write(`rauta-ai: ${lines.join('\n')}\n`);
   process.exit(1);
 }
 
+function removeQuietly(file) {
+  try {
+    fs.unlinkSync(file);
+  } catch (err) {
+    // Already gone, or never created. Either way there is nothing to clean up.
+  }
+}
+
 function platformArch() {
   const platforms = { darwin: 'darwin', linux: 'linux' };
   const arches = { arm64: 'arm64', x64: 'amd64' };
@@ -30,8 +77,9 @@ function platformArch() {
   const arch = arches[process.arch];
   if (!platform || !arch) {
     fail(
-      `no prebuilt binary for ${process.platform}/${process.arch} — ` +
-        'darwin/linux on arm64/amd64 are published. See https://rauta.ai/docs',
+      `no prebuilt binary for ${process.platform}/${process.arch}.`,
+      'Published builds are darwin and linux, on arm64 and amd64.',
+      `Nothing was installed. Build from source or ask for this target: ${DOCS}`,
     );
   }
   return { platform, arch };
@@ -49,41 +97,13 @@ function cachedBinaryPath() {
   return path.join(cacheRoot, 'rauta-ai', `v${pkg.version}`, 'rauta-ai');
 }
 
-function download(url, dest, redirects = 0) {
-  return new Promise((resolve, reject) => {
-    if (redirects > 5) return reject(new Error('too many redirects'));
-    https
-      .get(url, { headers: { 'user-agent': `rauta-npx/${pkg.version}` } }, (res) => {
-        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          res.resume();
-          return resolve(download(new URL(res.headers.location, url).href, dest, redirects + 1));
-        }
-        if (res.statusCode !== 200) {
-          res.resume();
-          return reject(new Error(`download failed: ${res.statusCode} ${url}`));
-        }
-        const tmp = `${dest}.download-${process.pid}`;
-        const out = fs.createWriteStream(tmp, { mode: 0o755 });
-        res.pipe(out);
-        out.on('finish', () =>
-          out.close(() => {
-            try {
-              fs.renameSync(tmp, dest);
-              resolve();
-            } catch (err) {
-              reject(err);
-            }
-          }),
-        );
-        out.on('error', reject);
-        res.on('error', reject);
-      })
-      .on('error', reject);
-  });
-}
-
 function candidateUrls() {
-  const bases = [PRIMARY_BASE, FALLBACK_BASE];
+  // An explicitly configured mirror is used on its own. Silently reaching out
+  // to the public CDN behind an operator's back can breach an egress policy,
+  // and the second base exists for the artifact RENAME window rather than for
+  // host failover -- by default both constants are the same host anyway.
+  const overridden = Boolean(process.env.RAUTA_CLI_BASE || process.env.INFRA_ARENA_CLI_BASE);
+  const bases = overridden ? [PRIMARY_BASE] : [PRIMARY_BASE, FALLBACK_BASE];
   const artifacts = artifactNames();
   const urls = [];
   for (const artifact of artifacts) {
@@ -92,36 +112,359 @@ function candidateUrls() {
       urls.push(`${base}/${artifact}`);
     }
   }
-  // Deduplicate if PRIMARY === FALLBACK via env override.
+  // Deduplicate, preserving order: the first entry is the canonical artifact at
+  // the version this package pins, and error reporting leads with it.
   const seen = new Set();
   return urls.filter((u) => (seen.has(u) ? false : (seen.add(u), true)));
 }
 
+/** First four bytes as lowercase hex, or '' when the file is shorter. */
+function magicOf(buf) {
+  return buf.length >= 4 ? buf.subarray(0, 4).toString('hex') : '';
+}
+
+function looksExecutable(buf) {
+  return EXECUTABLE_MAGIC.indexOf(magicOf(buf)) !== -1;
+}
+
+/** Plain-English name for whatever arrived, for an error a human can act on. */
+function describeContent(buf, contentType) {
+  const head = buf.subarray(0, 512).toString('utf8').trim().toLowerCase();
+  if (head.indexOf('<!doctype html') === 0 || head.indexOf('<html') === 0) {
+    return 'an HTML page';
+  }
+  if (head.charAt(0) === '{' || head.charAt(0) === '[') return 'a JSON document';
+  if (contentType) return `content of type ${contentType.split(';')[0]}`;
+  return 'something that is not an executable';
+}
+
+function statusExplanation(status) {
+  if (status === 404) return 'not found -- nothing is published at that path';
+  if (status === 403) return 'forbidden -- the CDN refused the request';
+  if (status >= 500) return 'server error at the CDN';
+  return 'unexpected status';
+}
+
+/** True for transport failures (no HTTP response at all). */
+function isNetworkError(err) {
+  const code = err && err.code;
+  return (
+    code === 'ENOTFOUND' ||
+    code === 'EAI_AGAIN' ||
+    code === 'ECONNREFUSED' ||
+    code === 'ECONNRESET' ||
+    code === 'ETIMEDOUT' ||
+    code === 'EHOSTUNREACH' ||
+    code === 'ENETUNREACH' ||
+    code === 'CERT_HAS_EXPIRED' ||
+    code === 'RAUTA_TIMEOUT'
+  );
+}
+
+/**
+ * Fetch a URL into memory, following redirects. Resolves with the HTTP status,
+ * headers and body for ANY status -- callers decide what a status means. It
+ * rejects only when no complete response arrived (DNS, TLS, timeout, a
+ * connection dropped mid-body).
+ *
+ * The body is buffered rather than streamed to disk on purpose: nothing touches
+ * the filesystem until it has been verified, so a rejected download cannot
+ * leave a temp file behind or race an exec.
+ */
+function fetchUrl(url, redirects) {
+  redirects = redirects || 0;
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) {
+      reject(new Error(`too many redirects fetching ${url}`));
+      return;
+    }
+    const options = {
+      headers: {
+        'user-agent': `rauta-npx/${pkg.version}`,
+        // Identity, explicitly: Node does not decompress responses, so a gzipped
+        // body would arrive as gzip bytes and fail the magic-byte check even
+        // though the artifact was perfectly good.
+        'accept-encoding': 'identity',
+        accept: 'application/octet-stream, */*',
+      },
+    };
+    let settled = false;
+    const req = https.get(url, options, (res) => {
+      const status = res.statusCode;
+      if (status >= 300 && status < 400 && res.headers.location) {
+        res.resume();
+        const next = new URL(res.headers.location, url).href;
+        settled = true;
+        fetchUrl(next, redirects + 1).then(resolve, reject);
+        return;
+      }
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('aborted', () => {
+        if (settled) return;
+        settled = true;
+        const err = new Error(`the connection closed before ${url} finished downloading`);
+        err.code = 'ECONNRESET';
+        reject(err);
+      });
+      res.on('error', (err) => {
+        if (settled) return;
+        settled = true;
+        reject(err);
+      });
+      res.on('end', () => {
+        if (settled) return;
+        settled = true;
+        resolve({ status, headers: res.headers, body: Buffer.concat(chunks) });
+      });
+    });
+    req.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.setTimeout(IDLE_TIMEOUT_MS, () => {
+      const err = new Error(
+        `${url} stopped responding after ${IDLE_TIMEOUT_MS / 1000}s`,
+      );
+      err.code = 'RAUTA_TIMEOUT';
+      req.destroy(err);
+    });
+  });
+}
+
+/**
+ * Fetch one artifact URL and prove it is an executable before returning it.
+ * Rejects with a message that names the URL, so the caller can attribute a
+ * failure to the exact path that produced it.
+ */
+async function fetchArtifact(url) {
+  const res = await fetchUrl(url);
+  if (res.status !== 200) {
+    const err = new Error(`HTTP ${res.status} (${statusExplanation(res.status)})`);
+    err.httpStatus = res.status;
+    throw err;
+  }
+  const contentType = String(res.headers['content-type'] || '');
+  const declared = Number(res.headers['content-length']);
+  if (Number.isFinite(declared) && declared !== res.body.length) {
+    throw new Error(
+      `truncated: the CDN promised ${declared} bytes and sent ${res.body.length}`,
+    );
+  }
+  if (!looksExecutable(res.body)) {
+    // The cached-HTML loop starts here, and this is where it now stops.
+    throw new Error(
+      `answered 200 with ${describeContent(res.body, contentType)}, not an executable` +
+        ' (a CDN serves the website when the artifact path is missing)',
+    );
+  }
+  return res.body;
+}
+
+/**
+ * Look for `<artifact>.sha256` beside the binary. Returns the hex digest, or
+ * null when none is published.
+ *
+ * scripts/build-cli.sh now emits one beside every artifact it publishes,
+ * including the back-compat version directories, so on a current deploy this
+ * returns a digest and the caller verifies for real.
+ *
+ * Degrading to null rather than failing is still deliberate, for one release
+ * more. A shim published BEFORE the build emitted checksums is pinned to its
+ * own /cli/<version>/ directory, and hard-failing here would break those
+ * installs on the one path they cannot update from. Once no live shim predates
+ * the change, absence becomes worth escalating to a refusal.
+ *
+ * That escalation matters more than it sounds: an unverified download is how a
+ * 2048-byte file full of 'B' came to be installed as the binary on the
+ * maintainer's own machine (found 2026-08-12), where it had been silently
+ * failing every session-start hook with nothing anywhere reporting it.
+ */
+async function publishedChecksum(url) {
+  let res;
+  try {
+    res = await fetchUrl(`${url}.sha256`);
+  } catch (err) {
+    return null;
+  }
+  if (res.status !== 200) return null;
+  // The sidecar is served by the same CDN, so it can come back as the same HTML
+  // fallback. A real one is a short line of `<digest>  <filename>`; anything
+  // else is treated as "not published" rather than as a mismatch, because
+  // failing an install on a stray hex string in a web page would be absurd.
+  const text = res.body.toString('utf8');
+  if (text.length > 4096 || /^\s*</.test(text)) return null;
+  const match = /^\s*([a-f0-9]{64})\b/i.exec(text);
+  return match ? match[1].toLowerCase() : null;
+}
+
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+/**
+ * Land verified bytes at `dest` atomically: write a private temp file in the
+ * same directory, make it executable only once it is complete, then rename.
+ * The temp name carries randomness as well as the pid because a cache directory
+ * can be a shared mount where pids repeat.
+ */
+function installBinary(buf, dest) {
+  const tmp = `${dest}.download-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+  try {
+    fs.writeFileSync(tmp, buf, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o755);
+    fs.renameSync(tmp, dest);
+  } catch (err) {
+    removeQuietly(tmp);
+    throw err;
+  }
+}
+
+/** Read the first bytes of a cached file without loading the whole binary. */
+function cachedLooksExecutable(bin) {
+  let fd;
+  try {
+    fd = fs.openSync(bin, 'r');
+    const head = Buffer.alloc(4);
+    const read = fs.readSync(fd, head, 0, 4, 0);
+    return read === 4 && looksExecutable(head);
+  } catch (err) {
+    return false;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch (err) {
+        // Nothing useful to do about a failed close on a read-only probe.
+      }
+    }
+  }
+}
+
+/** Build the message for "every candidate URL failed". */
+function downloadFailure(attempts) {
+  const lines = [
+    `could not download the Rauta CLI v${pkg.version} for ${process.platform}/${process.arch}.`,
+    'Tried, in order:',
+  ];
+  for (const attempt of attempts) {
+    lines.push(`  ${attempt.url}`);
+    lines.push(`    ${attempt.message}`);
+  }
+  lines.push('Nothing was installed and the cache is unchanged.');
+  if (attempts.every((a) => a.network)) {
+    lines.push(
+      'Every attempt failed before the CDN answered, which usually means no route out.',
+      'If you are behind an egress proxy or use an internal mirror, point the shim at it:',
+      '  RAUTA_CLI_BASE=https://mirror.example.com/cli npx rauta-ai <command>',
+    );
+  } else {
+    lines.push(
+      `Next step: check ${DOCS} for the current install command, or set RAUTA_CLI_BASE`,
+      'to a mirror that carries the artifact above.',
+    );
+  }
+  return lines;
+}
+
 async function ensureBinary(bin) {
-  if (fs.existsSync(bin)) return;
-  fs.mkdirSync(path.dirname(bin), { recursive: true });
+  if (fs.existsSync(bin)) {
+    if (cachedLooksExecutable(bin)) return;
+    // A cache poisoned by an older shim that accepted an error page. Left in
+    // place it fails ENOEXEC on every single run, forever, and deleting the
+    // cache by hand just downloads the same page again.
+    removeQuietly(bin);
+    process.stderr.write(
+      `rauta-ai: the cached file at ${bin} was not an executable, so it was deleted.\n` +
+        'rauta-ai: downloading a fresh copy.\n',
+    );
+  }
+  try {
+    fs.mkdirSync(path.dirname(bin), { recursive: true });
+  } catch (err) {
+    fail(
+      `cannot create the cache directory ${path.dirname(bin)} (${err.code || err.message}).`,
+      'The CLI is downloaded once and cached there, so nothing can run without it.',
+      'Nothing was installed.',
+      'Next step: point the cache at a directory you own --',
+      '  XDG_CACHE_HOME=$HOME/.cache npx rauta-ai <command>',
+    );
+  }
   const urls = candidateUrls();
   process.stderr.write(
-    `Fetching rauta-ai v${pkg.version} for ${process.platform}/${process.arch}…\n`,
+    `Fetching rauta-ai v${pkg.version} for ${process.platform}/${process.arch}...\n`,
   );
-  let lastErr;
+  const attempts = [];
   for (const url of urls) {
+    let body;
     try {
-      await download(url, bin);
-      return;
+      body = await fetchArtifact(url);
     } catch (err) {
-      lastErr = err;
+      attempts.push({
+        url,
+        message: err.message,
+        network: isNetworkError(err),
+      });
+      continue;
     }
+    const expected = await publishedChecksum(url);
+    if (expected === null) {
+      process.stderr.write(
+        `rauta-ai: no checksum published at ${url}.sha256, so integrity was not verified.\n`,
+      );
+    } else {
+      const actual = sha256(body);
+      if (actual !== expected) {
+        fail(
+          `the binary at ${url} does not match its published checksum.`,
+          `  expected ${expected}`,
+          `  actual   ${actual}`,
+          'That means the download was corrupted or tampered with in transit.',
+          'Nothing was installed and the cache is unchanged.',
+          `Next step: retry on a different network, or report it at ${DOCS}`,
+        );
+      }
+      process.stderr.write(`rauta-ai: checksum verified (sha256 ${actual.slice(0, 12)}...).\n`);
+    }
+    try {
+      installBinary(body, bin);
+    } catch (err) {
+      fail(
+        `downloaded the CLI but could not save it to ${bin} (${err.code || err.message}).`,
+        'The download itself was fine, so this is about permissions or disk space.',
+        'Nothing was installed.',
+        'Next step: free some space, or use a cache directory you own --',
+        '  XDG_CACHE_HOME=$HOME/.cache npx rauta-ai <command>',
+      );
+    }
+    return;
   }
-  throw lastErr || new Error('download failed');
+  fail.apply(null, downloadFailure(attempts));
 }
 
 async function main() {
   const bin = cachedBinaryPath();
   await ensureBinary(bin);
   const result = spawnSync(bin, process.argv.slice(2), { stdio: 'inherit' });
-  if (result.error) fail(result.error.message);
+  if (result.error) {
+    const code = result.error.code;
+    if (code === 'ENOEXEC' || code === 'EACCES') {
+      removeQuietly(bin);
+      fail(
+        `the cached CLI at ${bin} could not be executed (${code}).`,
+        'It has been deleted, so the next run downloads a fresh copy.',
+        'If this repeats, something on the network is replacing the download:',
+        `set RAUTA_CLI_BASE to a mirror you trust, or install from ${DOCS}`,
+      );
+    }
+    fail(
+      `could not start the Rauta CLI: ${result.error.message}`,
+      `The binary is installed at ${bin} and was left in place.`,
+      `Next step: run it directly to see the underlying error -- ${bin} version`,
+    );
+  }
   process.exit(result.status === null ? 1 : result.status);
 }
 
-main().catch((err) => fail(err.message));
+main().catch((err) => fail(err && err.message ? err.message : String(err)));

package/bin/rauta-box.js

@@ -25,4 +25,16 @@ const argv = args[0] === 'box' ? args : ['box', ...args];
 const result = spawnSync(process.execPath, [path.join(__dirname, 'rauta-ai.js'), ...argv], {
   stdio: 'inherit',
 });
+// When the spawn itself fails, `status` is null and the delegate never ran, so
+// exiting on status alone gave the user an empty terminal and a bare exit 1 --
+// no output at all, nothing to search for. Say what broke and what to run.
+if (result.error) {
+  process.stderr.write(
+    `rauta-box: could not start the Rauta CLI -- ${result.error.message}\n` +
+      'Nothing was installed or changed.\n' +
+      'Next step: run the canonical form directly -- npx rauta-ai box ' +
+      `${argv.slice(1).join(' ')}\n`,
+  );
+  process.exit(1);
+}
 process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rauta-ai",
-  "version": "0.4.9",
+  "version": "0.5.101",
   "description": "CLI for Rauta (rauta.ai) \u2014 GPU infrastructure, compared in public. Canonical install: `npx rauta-ai`. Interim package name while unscoped `rauta` awaits npm similarity clearance. Sign up, connect provider keys (BYOK), buy prepaid credits, provision GPUs, and track AI spend from your terminal.",
   "bin": {
     "rauta-ai": "bin/rauta-ai.js",