spi-agent-gui 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 - macOS Apple Silicon/Intel candidates remain separate from public Linux releases. Developer ID signing and notarization are not configured.
 
+## 0.1.3
+
+- Show live runtime download percentage, transferred/total MiB and average speed every 10 seconds, followed by checksum/extraction/completion phases. Interactive npm lifecycle progress uses only its own controlling terminal when npm buffers script output; headless callers use stderr.
+- Replace the 180-second large-archive deadline with a bounded 60-minute overall budget and a separate 60-second network-inactivity timeout. `SPI_DOWNLOAD_TIMEOUT_SECONDS` accepts 60–21600 seconds without changing npm/Pi settings.
+- Resume interrupted archive transfers within the current installation with validated HTTP Range/If-Range; safely restart if the server ignores Range. Always verify the complete manifest size/SHA-256 before extraction or switching versions. No permanent download cache or cross-process resume is implied.
+- Preserve previous installations on download/integrity failure. Add slow/stalled/disconnected-transfer, unsafe-response and real npm-buffered private-PTY progress regression tests; extend the public-install test's download allowance without extending GUI test timeouts.
+
 ## 0.1.2
 
 - Linux x64/arm64 release containing the actual new editable buffer UI (not only Pi's native queue-count status).

package/README.md

@@ -4,6 +4,8 @@ Lightweight Pi package and desktop installer. Desktop binaries are downloaded fr
 
 The npm package name is `spi-agent-gui`. Install with `pi install npm:spi-agent-gui`, then run `spi`. The initial release supports Linux x64 and arm64; Windows/macOS are deferred. The package registers `/spi` and `/spi-install`; it never launches a GUI just because an extension was loaded. Project/temporary/CI installs and `SPI_SKIP_INSTALL=1` skip automatic system-wide side effects. If lifecycle scripts are disabled, use `/spi-install` or explicitly run `npx --package spi-agent-gui spi install`.
 
+Runtime downloads show percentage, received/total MiB and average speed every 10 seconds, including when interactive npm buffers its postinstall output. A healthy slow transfer has a one-hour overall budget, with a separate 60-second inactivity limit and up to three validated Range/If-Range attempts. The complete archive size/SHA-256 is always verified; prior runtime selection is preserved on failure. `SPI_DOWNLOAD_TIMEOUT_SECONDS` accepts 60–21600 seconds. Resume applies within one install, not across processes; no permanent cache is implied. Headless log capture can use `npm_config_foreground_scripts=true` for that command.
+
 `spi --help`, `spi doctor`, `spi update`, `spi rollback`, `spi uninstall`. Use `--bin-dir` if Pi's PATH directory is not writable or another spi command exists. No shell profile is edited. User preferences and Pi sessions survive uninstall. `pi remove` removes this package, not the independently installed desktop runtime.
 
 The installer requires Node.js 22.19+; the installed command can use its private Electron runtime's Node mode. Supported platforms are only those present in the verified Release manifest. Unsigned Windows/macOS binaries may trigger OS warnings; do not disable OS protections. Linux needs a glibc desktop environment.

package/dist/spi.cjs

@@ -11,7 +11,7 @@ var __commonJS = (cb, mod) => function __require() {
 var define_SPI_RELEASE_default;
 var init_define_SPI_RELEASE = __esm({
   "<define:__SPI_RELEASE__>"() {
-    define_SPI_RELEASE_default = { version: "0.1.2", repository: "DiamondGo/spi", packageName: "spi-agent-gui" };
+    define_SPI_RELEASE_default = { version: "0.1.3", repository: "DiamondGo/spi", packageName: "spi-agent-gui" };
   }
 });
 
@@ -4677,12 +4677,201 @@ var require_desktop = __commonJS({
   }
 });
 
+// packages/pi-spi/lib/download.cjs
+var require_download = __commonJS({
+  "packages/pi-spi/lib/download.cjs"(exports2, module2) {
+    "use strict";
+    init_define_SPI_RELEASE();
+    var fs2 = require("node:fs");
+    var fsp = require("node:fs/promises");
+    var crypto2 = require("node:crypto");
+    var { performance } = require("node:perf_hooks");
+    var DEFAULTS = Object.freeze({ totalMs: 36e5, metadataMs: 18e4, idleMs: 6e4, attempts: 3, delayMs: 1e3, progressMs: 1e4 });
+    function error(message, fatal = false) {
+      return Object.assign(new Error(message), { fatal });
+    }
+    function trustedURL2(value) {
+      const u = new URL(value);
+      if (u.username || u.password) throw error("URL credentials are not supported", true);
+      const loopback = ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname);
+      if (process.env.SPI_ALLOW_TEST_HTTP === "1" && loopback && u.protocol === "http:") return u;
+      if (u.protocol !== "https:" || !(u.hostname === "github.com" || u.hostname === "api.github.com" || u.hostname.endsWith(".githubusercontent.com"))) throw error("Only GitHub HTTPS release URLs are supported", true);
+      return u;
+    }
+    function archiveTimeout() {
+      const raw = process.env.SPI_DOWNLOAD_TIMEOUT_SECONDS;
+      if (raw === void 0) return DEFAULTS.totalMs;
+      if (!/^\d+$/.test(raw) || !Number.isSafeInteger(Number(raw)) || Number(raw) < 60 || Number(raw) > 21600) throw error("SPI_DOWNLOAD_TIMEOUT_SECONDS must be an integer from 60 to 21600", true);
+      return Number(raw) * 1e3;
+    }
+    function progressReporter() {
+      let fd = 2, owned = false;
+      if (process.env.npm_lifecycle_event === "postinstall" && !process.stderr.isTTY && process.platform !== "win32") {
+        try {
+          fd = fs2.openSync("/dev/tty", fs2.constants.O_WRONLY | fs2.constants.O_NOCTTY);
+          owned = true;
+        } catch {
+        }
+      }
+      return {
+        write(message) {
+          try {
+            fs2.writeSync(fd, "[sPi] " + message + "\n");
+          } catch {
+          }
+        },
+        close() {
+          if (owned) {
+            try {
+              fs2.closeSync(fd);
+            } catch {
+            }
+          }
+        }
+      };
+    }
+    function status2(message) {
+      const reporter = progressReporter();
+      try {
+        reporter.write(message);
+      } finally {
+        reporter.close();
+      }
+    }
+    async function download2(url, file, max, options2 = {}) {
+      if (!Number.isSafeInteger(max) || max <= 0) throw error("Invalid download size limit", true);
+      const resume = !!options2.resume;
+      const policy = { ...DEFAULTS, totalMs: resume ? archiveTimeout() : DEFAULTS.metadataMs, ...options2.policy };
+      for (const key of ["totalMs", "idleMs", "attempts", "progressMs"]) if (!Number.isSafeInteger(policy[key]) || policy[key] <= 0) throw error("Invalid download policy", true);
+      if (options2.sha256 && !/^[a-f0-9]{64}$/i.test(options2.sha256)) throw error("Invalid download checksum", true);
+      const firstURL = trustedURL2(url);
+      const reporter = options2.progress ? progressReporter() : null;
+      const emit = options2.report || ((message) => reporter?.write(message));
+      const controller = new AbortController();
+      const totalTimer = setTimeout(() => controller.abort(error("Download exceeded its total time limit; increase SPI_DOWNLOAD_TIMEOUT_SECONDS (maximum 21600)", true)), policy.totalMs);
+      const started = performance.now();
+      let out, bytes = 0, etag, success = false, attempt = 0, progressTimer;
+      const report = () => {
+        const seconds = Math.max(1e-3, (performance.now() - started) / 1e3);
+        emit("Downloading runtime: " + (bytes / 1048576).toFixed(1) + "/" + (max / 1048576).toFixed(1) + " MiB (" + (success ? 100 : Math.min(99, Math.floor(bytes / max * 100))) + "%), " + (bytes / 1024 / seconds).toFixed(0) + " KiB/s, attempt " + attempt + "/" + policy.attempts);
+      };
+      try {
+        out = await fsp.open(file, "wx+", 384);
+        if (options2.progress || options2.report) {
+          emit("Downloading runtime; active transfers may take up to " + Math.round(policy.totalMs / 6e4) + " minutes. Interrupted transfers resume when supported.");
+          progressTimer = setInterval(report, policy.progressMs);
+        }
+        for (attempt = 1; attempt <= policy.attempts; attempt++) {
+          controller.signal.throwIfAborted();
+          if (options2.progress || options2.report) report();
+          if (attempt > 1 && !resume) {
+            await out.truncate(0);
+            bytes = 0;
+            etag = void 0;
+          }
+          const idle = new AbortController();
+          let idleTimer, response;
+          const touch = () => {
+            clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => idle.abort(error("Download stalled: no network data for " + Math.round(policy.idleMs / 1e3) + " seconds")), policy.idleMs);
+          };
+          const signal = AbortSignal.any([controller.signal, idle.signal]);
+          try {
+            if (!(resume && bytes === max)) {
+              let current = firstURL, redirects = 0;
+              const offset = bytes;
+              const headers = { "User-Agent": "sPi-installer", Accept: "application/octet-stream", "Accept-Encoding": "identity" };
+              if (resume && offset) {
+                headers.Range = "bytes=" + offset + "-";
+                if (etag) headers["If-Range"] = etag;
+              }
+              while (true) {
+                touch();
+                response = await fetch(current, { redirect: "manual", signal, headers });
+                if (![301, 302, 303, 307, 308].includes(response.status)) break;
+                await response.body?.cancel();
+                if (++redirects > 5) throw error("Too many download redirects", true);
+                const location = response.headers.get("location");
+                if (!location) throw error("Missing download redirect location", true);
+                current = trustedURL2(new URL(location, current));
+              }
+              if (response.status !== 200 && response.status !== 206) throw error("Download failed: HTTP " + response.status, ![408, 429].includes(response.status) && response.status < 500);
+              const encoding = response.headers.get("content-encoding");
+              if (encoding && encoding !== "identity") throw error("Encoded download responses cannot be safely resumed", true);
+              if (response.status === 206) {
+                const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get("content-range") || "");
+                if (!resume || !offset || !range || !range.slice(1).every((n) => Number.isSafeInteger(Number(n))) || Number(range[1]) !== offset || Number(range[2]) !== max - 1 || Number(range[3]) !== max) throw error("Invalid resumed download range", true);
+                if (etag && response.headers.get("etag") && response.headers.get("etag") !== etag) throw error("Resumed download validator changed", true);
+              } else if (offset) {
+                await out.truncate(0);
+                bytes = 0;
+                etag = void 0;
+                emit("Server did not honor resume; restarting this transfer safely.");
+              }
+              const length = response.headers.get("content-length");
+              if (length !== null && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)) || Number(length) > max - bytes)) throw error("Download size limit exceeded", true);
+              const validator = response.headers.get("etag");
+              if (validator && /^"[^\r\n]{1,500}"$/.test(validator)) etag = validator;
+              touch();
+              for await (const chunk of response.body) {
+                touch();
+                if (chunk.length > max - bytes) throw error("Download size limit exceeded", true);
+                let written = 0;
+                while (written < chunk.length) {
+                  const result = await out.write(chunk, written, chunk.length - written, bytes);
+                  if (!result.bytesWritten) throw error("Cannot write downloaded data", true);
+                  written += result.bytesWritten;
+                  bytes += result.bytesWritten;
+                }
+              }
+              if (resume && bytes !== max) throw error("Download ended before the expected size");
+            }
+            clearTimeout(idleTimer);
+            if (options2.sha256) {
+              const digest = crypto2.createHash("sha256");
+              for await (const chunk of fs2.createReadStream(file)) digest.update(chunk);
+              if (digest.digest("hex") !== options2.sha256.toLowerCase()) throw error("Release checksum mismatch", true);
+            }
+            controller.signal.throwIfAborted();
+            success = true;
+            if (options2.progress || options2.report) {
+              report();
+              emit("Download verified; preparing the runtime.");
+            }
+            return;
+          } catch (caught) {
+            const reason = controller.signal.aborted ? controller.signal.reason : idle.signal.aborted ? idle.signal.reason : caught;
+            if (reason.fatal || attempt === policy.attempts) throw reason;
+            emit("Transfer interrupted; retrying" + (resume && bytes ? " from " + (bytes / 1048576).toFixed(1) + " MiB" : "") + " (" + attempt + "/" + policy.attempts + ").");
+          } finally {
+            clearTimeout(idleTimer);
+            if (response?.body && !response.body.locked) {
+              try {
+                await response.body.cancel();
+              } catch {
+              }
+            }
+          }
+          await new Promise((resolve) => setTimeout(resolve, policy.delayMs * attempt));
+        }
+      } finally {
+        clearTimeout(totalTimer);
+        clearInterval(progressTimer);
+        await out?.close();
+        if (out && !success) await fsp.rm(file, { force: true });
+        reporter?.close();
+      }
+    }
+    module2.exports = { download: download2, trustedURL: trustedURL2, archiveTimeout, progressReporter, status: status2, DEFAULTS };
+  }
+});
+
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "spi",
-      version: "0.1.2",
+      version: "0.1.3",
       description: "sPi - Simple Pi Agent GUI",
       private: true,
       license: "UNLICENSED",
@@ -4706,7 +4895,7 @@ var require_package = __commonJS({
         "dist:manifest": "node scripts/distribution.cjs manifest",
         "dist:appimage": "electron-vite build && electron-builder --linux AppImage",
         "check:privacy": "node scripts/privacy.cjs",
-        "test:installer": "node scripts/installer.test.cjs",
+        "test:installer": "node scripts/download.test.cjs && node scripts/installer.test.cjs",
         "test:distribution": "node scripts/with-display.cjs scripts/distribution.test.cjs",
         typecheck: "tsc --noEmit -p tsconfig.node.json && tsc --noEmit -p tsconfig.web.json",
         "test:launch": "node scripts/launch.test.cjs",
@@ -4764,7 +4953,6 @@ var require_release_config = __commonJS({
 // packages/pi-spi/lib/installer.cjs
 init_define_SPI_RELEASE();
 var fs = require("node:fs");
-var fsp = require("node:fs/promises");
 var path = require("node:path");
 var os = require("node:os");
 var crypto = require("node:crypto");
@@ -4773,6 +4961,7 @@ var { pipeline } = require("node:stream/promises");
 var tar = require_index_min();
 var yauzl = require_yauzl();
 var { syncDesktopEntry, assertDesktopOwned, removeDesktopEntry } = require_desktop();
+var { download, trustedURL, status } = require_download();
 var BUILD = typeof define_SPI_RELEASE_default === "undefined" ? { version: require_package().version, repository: require_release_config().repository, packageName: require_release_config().npmPackage } : define_SPI_RELEASE_default;
 var OWNER = "sPi-installer-v1";
 var MAX_ARCHIVE = 700 * 1024 * 1024;
@@ -4939,45 +5128,6 @@ async function extractZip(file, dest) {
   }
   checkExtractedLinks(entries, dest);
 }
-function trustedURL(value) {
-  const u = new URL(value);
-  if (u.username || u.password) fail("URL credentials are not supported");
-  const loopback = ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname);
-  if (process.env.SPI_ALLOW_TEST_HTTP === "1" && loopback && u.protocol === "http:") return u;
-  if (u.protocol !== "https:" || !(u.hostname === "github.com" || u.hostname === "api.github.com" || u.hostname.endsWith(".githubusercontent.com"))) fail("Only GitHub HTTPS release URLs are supported");
-  return u;
-}
-async function download(url, file, max = MAX_ARCHIVE) {
-  let current = trustedURL(url), response;
-  for (let n = 0; n < 6; n++) {
-    response = await fetch(current, { redirect: "manual", signal: AbortSignal.timeout(18e4), headers: { "User-Agent": "sPi-installer", "Accept": "application/octet-stream" } });
-    if ([301, 302, 303, 307, 308].includes(response.status)) {
-      current = trustedURL(new URL(response.headers.get("location"), current));
-      await response.body?.cancel();
-      continue;
-    }
-    break;
-  }
-  if (!response?.ok) {
-    await response?.body?.cancel();
-    fail("Download failed: HTTP " + response?.status);
-  }
-  if (Number(response.headers.get("content-length")) > max) {
-    await response.body.cancel();
-    fail("Download size limit exceeded");
-  }
-  const out = await fsp.open(file, "wx", 384);
-  let bytes = 0;
-  try {
-    for await (const chunk of response.body) {
-      bytes += chunk.length;
-      if (bytes > max) fail("Download size limit exceeded");
-      await out.writeFile(chunk);
-    }
-  } finally {
-    await out.close();
-  }
-}
 async function fetchJSON(url) {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "spi-metadata-"));
   try {
@@ -5104,6 +5254,7 @@ async function install(options2 = {}) {
     const stage = fs.mkdtempSync(path.join(root, ".staging-"));
     try {
       const base = options2.archive ? null : baseURL(v);
+      if (base) status("Preparing sPi " + v + " (" + t + "); retrieving the release manifest.");
       const manifest = options2.manifest ? readJSON(options2.manifest) : await fetchJSON(base + "/release-manifest.json");
       const item = manifest.targets?.[t];
       if (manifest.schemaVersion !== 1 || manifest.version !== v || !item) fail("Release does not support this version/platform");
@@ -5120,16 +5271,10 @@ async function install(options2 = {}) {
         if (!fs.statSync(options2.archive).isFile() || fs.statSync(options2.archive).size !== item.size) fail("Archive size mismatch");
         fs.copyFileSync(options2.archive, archive);
       } else {
-        for (let attempt = 0; ; attempt++) try {
-          await download(base + "/" + item.file, archive, item.size);
-          break;
-        } catch (error) {
-          fs.rmSync(archive, { force: true });
-          if (attempt === 2) throw error;
-          await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
-        }
+        await download(base + "/" + item.file, archive, item.size, { resume: true, sha256: item.sha256, progress: true });
       }
       if (fs.statSync(archive).size !== item.size || hash(archive) !== item.sha256.toLowerCase()) fail("Release checksum/size mismatch");
+      status("Checksum verified; extracting the runtime. Please wait.");
       if (item.file.endsWith(".tar.gz")) await extractTar(archive, stage);
       else await extractZip(archive, stage);
       for (const f of [item.entry, item.permissionExtension]) if (!fs.statSync(path.join(stage, f)).isFile()) fail("Release is incomplete");
@@ -5157,6 +5302,7 @@ async function install(options2 = {}) {
       }
       if (previous && previous.directory !== directory) atomicJSON(path.join(root, "previous.json"), previous);
       console.log("Installed sPi " + v + " (" + t + ")");
+      if (process.env.npm_lifecycle_event === "postinstall" && !process.stdout.isTTY) status("Installed sPi " + v + " (" + t + "). Close and reopen any old window to use the new runtime.");
       return readCurrent(root);
     } finally {
       fs.rmSync(stage, { recursive: true, force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spi-agent-gui",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "sPi - Simple Pi Agent GUI installer and Pi launcher",
   "type": "module",
   "license": "UNLICENSED",