prized 0.18.0-rc.5 → 0.18.0

package/bin/prized.js

@@ -7,19 +7,21 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { ensureCli } from '../lib/install.js';
 import { isReleaseVersion } from '../lib/release.js';
+import { reporter } from '../lib/report.js';
 
 const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const report = reporter(process.stderr);
 
 try {
   if (!isReleaseVersion(version)) {
     throw new Error(`this is a development copy (${version}); run a published version: npx prized`);
   }
-  const bin = await ensureCli(version, { log: (line) => process.stderr.write(`${line}\n`) });
+  const bin = await ensureCli(version, { log: report.log, progress: report.progress });
   const args = process.argv.slice(2);
   const run = spawnSync(bin, args.length > 0 ? args : ['start'], { stdio: 'inherit' });
   if (run.error) throw run.error;
   process.exit(run.status ?? 1);
 } catch (err) {
-  process.stderr.write(`prized: ${err instanceof Error ? err.message : String(err)}\n`);
+  report.fail(err instanceof Error ? err.message : String(err));
   process.exit(1);
 }

package/lib/install.js

@@ -22,6 +22,9 @@ export async function ensureCli(version, opts = {}) {
     root = cacheRoot(),
     fetchImpl = fetch,
     log = () => {},
+    progress = () => {},
+    stallMs = STALL_MS,
+    attempts = ATTEMPTS,
   } = opts;
   const dir = join(root, version);
   const bin = join(dir, binaryName(platform));
@@ -30,10 +33,11 @@ export async function ensureCli(version, opts = {}) {
   const asset = assetFor(version, platform, arch);
   const from = `${base}/cli/v${version}`;
   log(`Downloading Prized ${version}…`);
+  const fetchOpts = { fetchImpl, stallMs, attempts, log };
   const [sums, sig, archive] = await Promise.all([
-    get(fetchImpl, `${from}/SHA256SUMS`),
-    get(fetchImpl, `${from}/SHA256SUMS.minisig`),
-    get(fetchImpl, `${from}/${asset}`),
+    get(`${from}/SHA256SUMS`, fetchOpts),
+    get(`${from}/SHA256SUMS.minisig`, fetchOpts),
+    get(`${from}/${asset}`, { ...fetchOpts, progress }),
   ]);
   const trusted = verifyMinisign(sums, sig, pubkey);
   if (trusted !== `prized ${version}`) {
@@ -104,9 +108,83 @@ export function sumFor(sums, name) {
   return null;
 }
 
-async function get(fetchImpl, url) {
-  const res = await fetchImpl(url, { redirect: 'follow' });
-  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
-  return Buffer.from(await res.arrayBuffer());
+/** No bytes for this long, connecting included, and a download is dropped. */
+const STALL_MS = 30_000;
+/** Tries per file: a stall, a dropped connection or a 5xx is tried again. */
+const ATTEMPTS = 3;
+
+/**
+ * The body at url. A connection can stop moving without closing (a Wi-Fi
+ * roam, a middlebox) and fetch has no timeout of its own: without one the
+ * first `npx prized` sat on "Downloading…" for good. Each try is dropped
+ * once no bytes arrived for stallMs; a stall, a network error or a 5xx is
+ * tried again, anything else (a 404) is the answer.
+ */
+async function get(url, { fetchImpl, stallMs, attempts, log, progress = () => {} }) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await getOnce(url, fetchImpl, stallMs, progress);
+    } catch (err) {
+      if (!err.retry || attempt >= attempts) {
+        if (err.retry) err.message += ` (tried ${attempts} times; check your connection and run npx prized again)`;
+        throw err;
+      }
+      log(`${err.message}; trying again…`);
+    }
+  }
+}
+
+async function getOnce(url, fetchImpl, stallMs, progress) {
+  const ac = new AbortController();
+  const stalled = new Error(`the download of ${url.slice(url.lastIndexOf('/') + 1)} stalled (nothing for ${Math.round(stallMs / 1000)} s)`);
+  stalled.retry = true;
+  let timer;
+  const arm = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => ac.abort(stalled), stallMs);
+  };
+  const failed = (err) => {
+    if (ac.signal.aborted) return stalled;
+    const e = new Error(`${url}: ${err instanceof Error ? err.message : String(err)}`);
+    e.retry = true;
+    return e;
+  };
+  arm();
+  try {
+    let res;
+    try {
+      res = await fetchImpl(url, { redirect: 'follow', signal: ac.signal });
+    } catch (err) {
+      throw failed(err);
+    }
+    if (!res.ok) {
+      // Unread, the answer's body can hold its connection through the
+      // retries that follow.
+      await res.body?.cancel().catch(() => {});
+      const e = new Error(`${url} answered ${res.status}`);
+      e.retry = res.status >= 500;
+      throw e;
+    }
+    const total = Number(res.headers?.get?.('content-length')) || 0;
+    const reader = res.body.getReader();
+    const chunks = [];
+    let got = 0;
+    for (;;) {
+      let step;
+      try {
+        step = await reader.read();
+      } catch (err) {
+        throw failed(err);
+      }
+      if (step.done) break;
+      chunks.push(step.value);
+      got += step.value.length;
+      arm();
+      progress(got, total);
+    }
+    return Buffer.concat(chunks);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 

package/lib/report.js

@@ -0,0 +1,29 @@
+// What `npx prized` prints while it fetches the CLI, on stderr: a line per
+// event, and on a terminal the archive's progress rewriting one line under
+// "Downloading…" so a slow download does not read as stuck. Any line that
+// follows a progress line in flight (a retry notice, the final error)
+// clears it first rather than trailing the percentage.
+
+/** A reporter over out (a stream with write and isTTY). */
+export function reporter(out) {
+  let shown = -1;
+  const midLine = () => shown >= 0 && shown < 100;
+  const clear = () => (midLine() ? '\r\x1b[2K' : '');
+  return {
+    log(line) {
+      out.write(`${clear()}${line}\n`);
+      if (midLine()) shown = -1;
+    },
+    progress(got, total) {
+      if (!out.isTTY || !total) return;
+      const pct = Math.min(100, Math.floor((got * 100) / total));
+      if (pct === shown) return;
+      shown = pct;
+      out.write(`\r\x1b[2K  ${pct}% of ${(total / 1e6).toFixed(1)} MB${pct >= 100 ? '\n' : ''}`);
+    },
+    fail(message) {
+      out.write(`${clear()}prized: ${message}\n`);
+      shown = -1;
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prized",
-  "version": "0.18.0-rc.5",
+  "version": "0.18.0",
   "description": "Prized: a cloud dev box for your coding agents. npx prized signs you up, starts your box and sets up this machine.",
   "homepage": "https://prized.dev",
   "license": "UNLICENSED",