pandite 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Rizos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE 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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,77 @@
-# Temporary Holding Version
+# Pandite installer
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Installs [Pandite](https://github.com/xls/pandite), a fast offline image
+viewer, from its GitHub releases. Needs Node.js 18 or later. No
+dependencies, no install scripts.
+
+```sh
+npx pandite
+```
+
+## Commands
+
+| Command | Action |
+|---|---|
+| `npx pandite` | Install the latest release. |
+| `npx pandite install -v 0.2.0` | Install that release. `0.2.0` and `v0.2.0` are equal. |
+| `npx pandite update` | Install the latest release when it is newer than the installed one. Install it when Pandite is not installed. |
+| `npx pandite uninstall` | Remove Pandite. `--uninstall` is the same. |
+| `npx pandite --list` | Print the release versions, newest first. |
+
+| Option | Action |
+|---|---|
+| `-v`, `--version <version>` | The Pandite version to install. |
+| `--dry-run` | Print the downloads and the steps. Download and change nothing. |
+| `--force` | Install again when the same version is installed. |
+| `--system` | macOS: install in `/Applications`, not `~/Applications`. |
+| `--installer-version` | Print the version of this installer. |
+| `-h`, `--help` | Print the help. |
+
+`pandite-installer` is the same command. Exit codes: 0 done, 1 error,
+2 wrong command line.
+
+## Downloads and checks
+
+1. The installer reads the release from the GitHub API:
+   `https://api.github.com/repos/xls/pandite/releases`.
+2. It downloads one release file for your system and `SHA256SUMS.txt` of
+   the same release. It uses HTTPS only and follows redirects to HTTPS
+   addresses only.
+3. It compares the SHA-256 of the file with `SHA256SUMS.txt`. When the
+   SHA-256 differs, or `SHA256SUMS.txt` does not list the file, it deletes
+   the file and installs nothing.
+
+The requests carry the User-Agent `pandite-installer/<version>` and no
+token. The installer sends no other data.
+
+## Systems and install locations
+
+| System | Release file | Install |
+|---|---|---|
+| Windows x64, ARM64 | `pandite-<version>-<target>-setup.exe` | Runs the setup program silently for the current user, without administrator rights: `%LOCALAPPDATA%\Programs\Pandite`, Start menu, image file associations. |
+| macOS 11 or later | `pandite-<version>-universal-apple-darwin.zip`, else the `.dmg` | Copies `pandite.app` to `~/Applications`, or to `/Applications` with `--system`. Replaces an older copy. |
+| Linux x64, glibc 2.35 or later | `pandite-<version>-x86_64-unknown-linux-gnu.tar.gz` | Runs the `install.sh` of the tarball with `PREFIX=~/.local`: `~/.local/bin/pandite`, desktop entry, icons. |
+
+Other systems get a "not supported" message.
+
+The installer keeps the installed version in `installed.json` in its
+per-user folder:
+
+- Windows: `%LOCALAPPDATA%\pandite-installer`
+- macOS: `~/Library/Application Support/pandite-installer`
+- Linux: `$XDG_DATA_HOME/pandite-installer` or
+  `~/.local/share/pandite-installer`. The folder also keeps `install.sh`
+  for the uninstall.
+
+On Windows, the uninstall runs the uninstaller that the setup program
+registered. On Linux, it runs the kept `install.sh --uninstall`. On macOS,
+it deletes the app.
+
+## Notes
+
+- npx keeps a copy of the installer. To use the newest installer, run
+  `npx pandite@latest`.
+- `npm install -g pandite` adds a `pandite` command that is this installer,
+  not the image viewer. Use npx.
+
+License: MIT.

package/bin/pandite.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// The Pandite installer: npx pandite [install|update|uninstall] [options]
+// Run with --help for the commands and options.
+
+import process from 'node:process';
+
+const major = Number.parseInt(process.versions.node, 10);
+if (major < 18) {
+  process.stderr.write(`pandite-installer: Node.js 18 or later is required; this is Node.js ${process.versions.node}\n`);
+  process.exit(1);
+}
+
+const { main } = await import('../lib/cli.js');
+process.exitCode = await main(process.argv.slice(2));

package/lib/archive.js

@@ -0,0 +1,153 @@
+// Unpack zip and .tar.gz release files with the Node.js standard library.
+// Every entry must stay inside the target folder; links are refused.
+
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { gunzipSync, inflateRawSync } from 'node:zlib';
+import { InstallerError } from './errors.js';
+
+/** The parts of an archive entry name; refuses names that leave the folder. */
+function entryParts(name) {
+  const clean = name.replace(/\\/g, '/');
+  if (clean.startsWith('/') || /^[A-Za-z]:/.test(clean)) throw new InstallerError(`archive entry with an absolute path: ${name}`);
+  const parts = clean.split('/').filter((p) => p !== '' && p !== '.');
+  if (parts.some((p) => p === '..' || /[:\0]/.test(p))) throw new InstallerError(`archive entry outside its folder: ${name}`);
+  return parts;
+}
+
+function writeEntry(dest, parts, data, mode) {
+  const file = path.join(dest, ...parts);
+  mkdirSync(path.dirname(file), { recursive: true });
+  // "wx": an entry never replaces another entry or follows a link.
+  writeFileSync(file, data, { mode: mode || 0o644, flag: 'wx' });
+}
+
+/** Unpack a zip file (stored or deflated entries) into `dest`. Returns the file names. */
+export function unzip(buf, dest) {
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 22 - 0xffff); i -= 1) {
+    if (buf.readUInt32LE(i) === 0x06054b50) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new InstallerError('not a zip file');
+  const count = buf.readUInt16LE(eocd + 10);
+  const cdSize = buf.readUInt32LE(eocd + 12);
+  const cdOffset = buf.readUInt32LE(eocd + 16);
+  if (count === 0xffff || cdOffset === 0xffffffff) throw new InstallerError('zip64 files are not supported');
+  if (cdOffset + cdSize > eocd) throw new InstallerError('damaged zip file');
+  const files = [];
+  let p = cdOffset;
+  for (let n = 0; n < count; n += 1) {
+    if (p + 46 > eocd || buf.readUInt32LE(p) !== 0x02014b50) throw new InstallerError('damaged zip directory');
+    const madeBy = buf.readUInt16LE(p + 4);
+    const flags = buf.readUInt16LE(p + 8);
+    const method = buf.readUInt16LE(p + 10);
+    const compressed = buf.readUInt32LE(p + 20);
+    const size = buf.readUInt32LE(p + 24);
+    const nameLength = buf.readUInt16LE(p + 28);
+    const extraLength = buf.readUInt16LE(p + 30);
+    const commentLength = buf.readUInt16LE(p + 32);
+    const external = buf.readUInt32LE(p + 38);
+    const local = buf.readUInt32LE(p + 42);
+    const name = buf.toString(flags & 0x800 ? 'utf8' : 'latin1', p + 46, p + 46 + nameLength);
+    p += 46 + nameLength + extraLength + commentLength;
+    if (flags & 0x1) throw new InstallerError(`encrypted zip entry: ${name}`);
+    const parts = entryParts(name);
+    // macOS keeps extended attributes in __MACOSX; the app needs none.
+    if (parts.length === 0 || parts[0] === '__MACOSX') continue;
+    const unixMode = madeBy >> 8 === 3 ? external >>> 16 : 0;
+    const type = unixMode & 0o170000;
+    if (name.endsWith('/') || type === 0o040000) {
+      mkdirSync(path.join(dest, ...parts), { recursive: true });
+      continue;
+    }
+    if (type !== 0 && type !== 0o100000) throw new InstallerError(`zip entry is not a file or folder: ${name}`);
+    if (local + 30 > buf.length || buf.readUInt32LE(local) !== 0x04034b50) throw new InstallerError(`damaged zip entry: ${name}`);
+    const start = local + 30 + buf.readUInt16LE(local + 26) + buf.readUInt16LE(local + 28);
+    const raw = buf.subarray(start, start + compressed);
+    if (raw.length !== compressed) throw new InstallerError(`damaged zip entry: ${name}`);
+    let data;
+    if (method === 0) data = raw;
+    else if (method === 8) data = inflateRawSync(raw);
+    else throw new InstallerError(`zip entry ${name} uses compression method ${method}`);
+    if (data.length !== size) throw new InstallerError(`zip entry ${name} has the wrong size`);
+    writeEntry(dest, parts, data, unixMode & 0o777);
+    files.push(parts.join('/'));
+  }
+  return files;
+}
+
+function paxPath(data) {
+  let value = null;
+  let i = 0;
+  while (i < data.length) {
+    const space = data.indexOf(0x20, i);
+    if (space < 0) break;
+    const length = Number.parseInt(data.toString('latin1', i, space), 10);
+    if (!(length > 0) || i + length > data.length) break;
+    const record = data.toString('utf8', space + 1, i + length - 1);
+    const eq = record.indexOf('=');
+    if (eq > 0 && record.slice(0, eq) === 'path') value = record.slice(eq + 1);
+    i += length;
+  }
+  return value;
+}
+
+/** Unpack a .tar.gz file (ustar, GNU long names, pax paths) into `dest`. Returns the file names. */
+export function untar(gz, dest) {
+  const buf = gunzipSync(gz);
+  const files = [];
+  let longName = null;
+  let p = 0;
+  while (p + 512 <= buf.length) {
+    const header = buf.subarray(p, p + 512);
+    if (header.every((b) => b === 0)) break;
+    const text = (start, length) => {
+      const field = header.subarray(start, start + length);
+      const end = field.indexOf(0);
+      return field.toString('utf8', 0, end < 0 ? length : end);
+    };
+    const octal = (start, length) => {
+      if (header[start] & 0x80) throw new InstallerError('tar entry too large');
+      const digits = text(start, length).trim();
+      return digits ? Number.parseInt(digits, 8) : 0;
+    };
+    const size = octal(124, 12);
+    const mode = octal(100, 8);
+    const type = header[156] === 0 ? '0' : String.fromCharCode(header[156]);
+    let name = text(0, 100);
+    // POSIX ustar splits long names into prefix and name; GNU tar uses "L".
+    if (header.toString('latin1', 257, 263) === 'ustar\u0000') {
+      const prefix = text(345, 155);
+      if (prefix) name = `${prefix}/${name}`;
+    }
+    const data = buf.subarray(p + 512, p + 512 + size);
+    if (data.length !== size) throw new InstallerError('damaged tar file');
+    p += 512 + Math.ceil(size / 512) * 512;
+    if (type === 'L') {
+      longName = data.toString('utf8').replace(/\0+$/, '');
+      continue;
+    }
+    if (type === 'x') {
+      longName = paxPath(data) ?? longName;
+      continue;
+    }
+    if (type === 'g') continue;
+    if (longName !== null) {
+      name = longName;
+      longName = null;
+    }
+    const parts = entryParts(name);
+    if (type === '5') {
+      if (parts.length) mkdirSync(path.join(dest, ...parts), { recursive: true });
+      continue;
+    }
+    if (type !== '0' && type !== '7') throw new InstallerError(`tar entry is not a file or folder: ${name}`);
+    if (parts.length === 0) continue;
+    writeEntry(dest, parts, data, mode & 0o777);
+    files.push(parts.join('/'));
+  }
+  return files;
+}

package/lib/cli.js

@@ -0,0 +1,188 @@
+// The command line of the Pandite installer: parse the arguments, build the
+// context from the real system (or from the test doubles in `deps`) and
+// run one command. main() resolves the exit code.
+
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import process from 'node:process';
+import { InstallerError, usageError } from './errors.js';
+import { installCommand, listCommand, uninstallCommand, updateCommand } from './install.js';
+import { checkSupported, detectGlibc } from './platform.js';
+import { normalizeVersion } from './version.js';
+
+export const INSTALLER_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+
+export const HELP = `Pandite installer ${INSTALLER_VERSION}
+Installs Pandite, the fast offline image viewer, from its GitHub releases.
+
+Usage:
+  npx pandite [install] [-v <version>] [--force] [--system] [--dry-run]
+  npx pandite update [--force] [--dry-run]
+  npx pandite uninstall [--dry-run]
+  npx pandite --list
+
+Commands:
+  install                 install the latest release, or the release of -v
+                          (the default command)
+  update                  install the latest release when it is newer than
+                          the installed one; install it when Pandite is not
+                          installed
+  uninstall, --uninstall  remove Pandite
+
+Options:
+  -v, --version <version> the Pandite version to install: 0.1.0 or v0.1.0
+  --list                  print the Pandite versions on GitHub
+  --dry-run               print the downloads and the steps; download and
+                          change nothing
+  --force                 install again when the same version is installed
+  --system                macOS: install in /Applications, not ~/Applications
+  --installer-version     print the version of this installer
+  -h, --help              print this help
+
+pandite-installer is the same command.`;
+
+const COMMANDS = new Set(['install', 'update', 'uninstall']);
+const FLAGS = {
+  '--list': 'list',
+  '--dry-run': 'dryRun',
+  '--force': 'force',
+  '--system': 'system',
+  '--installer-version': 'installerVersion',
+  '-h': 'help',
+  '--help': 'help',
+};
+
+/** The options of a command line. Throws a usage error (exit code 2). */
+export function parseArgs(argv) {
+  const opts = {
+    command: null,
+    version: null,
+    list: false,
+    dryRun: false,
+    force: false,
+    system: false,
+    installerVersion: false,
+    help: false,
+  };
+  const setCommand = (command) => {
+    if (opts.command && opts.command !== command) throw usageError(`choose one command, not ${opts.command} and ${command}`);
+    opts.command = command;
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = String(argv[i]);
+    const eq = arg.startsWith('-') ? arg.indexOf('=') : -1;
+    const name = eq > 0 ? arg.slice(0, eq) : arg;
+    if (name === '-v' || name === '--version') {
+      let value = eq > 0 ? arg.slice(eq + 1) : argv[i + 1];
+      if (eq < 0) i += 1;
+      if (value === undefined || value === '' || String(value).startsWith('-')) {
+        throw usageError(`${name} needs a Pandite version, such as ${name} 0.1.0 (for the version of the installer: --installer-version)`);
+      }
+      value = normalizeVersion(value);
+      if (opts.version && opts.version !== value) throw usageError(`choose one version, not ${opts.version} and ${value}`);
+      opts.version = value;
+    } else if (FLAGS[name]) {
+      if (eq > 0) throw usageError(`${name} takes no value`);
+      opts[FLAGS[name]] = true;
+    } else if (name === '--uninstall') {
+      if (eq > 0) throw usageError(`${name} takes no value`);
+      setCommand('uninstall');
+    } else if (arg.startsWith('-')) {
+      throw usageError(`unknown option ${arg}`);
+    } else if (COMMANDS.has(arg)) {
+      setCommand(arg);
+    } else {
+      throw usageError(`unknown command "${arg}". This is the Pandite installer; it opens no images`);
+    }
+  }
+  if (opts.version && (opts.command === 'update' || opts.command === 'uninstall')) {
+    throw usageError(`${opts.command} takes no version. To install a named version, run: npx pandite install -v ${opts.version}`);
+  }
+  return opts;
+}
+
+/** Start a program and wait for it: { code, signal, stdout, stderr }. */
+export function runProcess(command, args, { env, capture = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const io = capture ? 'pipe' : 'ignore';
+    const child = spawn(command, args, { env, stdio: ['ignore', io, io], windowsHide: true });
+    const out = [];
+    const err = [];
+    child.stdout?.on('data', (chunk) => out.push(chunk));
+    child.stderr?.on('data', (chunk) => err.push(chunk));
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      resolve({ code, signal, stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8') });
+    });
+  });
+}
+
+/** The real system. Tests replace every key. */
+export function defaultDeps() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    glibc: undefined,
+    env: process.env,
+    home: os.homedir(),
+    tmpdir: os.tmpdir(),
+    systemApplications: '/Applications',
+    fetch: globalThis.fetch,
+    run: runProcess,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: () => Date.now(),
+    out: (line) => process.stdout.write(`${line}\n`),
+    err: (line) => process.stderr.write(`${line}\n`),
+  };
+}
+
+function makeContext(deps) {
+  const d = { ...defaultDeps(), ...deps };
+  const glibc = d.glibc !== undefined ? d.glibc : d.platform === 'linux' ? detectGlibc() : null;
+  return {
+    platform: d.platform,
+    arch: d.arch,
+    glibc,
+    env: d.env,
+    home: d.home,
+    tmpdir: d.tmpdir,
+    systemApplications: d.systemApplications,
+    run: d.run,
+    sleep: d.sleep,
+    net: { fetch: d.fetch, userAgent: `pandite-installer/${INSTALLER_VERSION}`, now: d.now },
+    out: d.out,
+    info: (line) => d.err(`pandite-installer: ${line}`),
+    error: (line) => d.err(`pandite-installer: ${line}`),
+  };
+}
+
+/** Run the installer with `argv`. Resolves the exit code: 0, 1, or 2 for a usage error. */
+export async function main(argv, deps = {}) {
+  const ctx = makeContext(deps);
+  try {
+    const opts = parseArgs(argv);
+    if (opts.help) {
+      ctx.out(HELP);
+      return 0;
+    }
+    if (opts.installerVersion) {
+      ctx.out(INSTALLER_VERSION);
+      return 0;
+    }
+    if (typeof ctx.net.fetch !== 'function') throw new InstallerError('this Node.js has no fetch; use Node.js 18 or later');
+    if (opts.list) return await listCommand(ctx);
+    checkSupported(ctx);
+    if (opts.system && ctx.platform !== 'darwin') throw usageError('--system works on macOS only');
+    if (opts.command === 'update') return await updateCommand(ctx, opts);
+    if (opts.command === 'uninstall') return await uninstallCommand(ctx, opts);
+    return await installCommand(ctx, opts);
+  } catch (error) {
+    if (error instanceof InstallerError) {
+      ctx.error(error.message);
+      return error.exitCode;
+    }
+    ctx.error(`unexpected error: ${error?.stack ?? error}`);
+    return 1;
+  }
+}

package/lib/errors.js

@@ -0,0 +1,18 @@
+// The error type of the installer.
+
+/**
+ * An error with a message for the user. The installer prints the message
+ * without a stack and exits with `exitCode` (1, or 2 for a usage error).
+ */
+export class InstallerError extends Error {
+  constructor(message, { exitCode = 1 } = {}) {
+    super(message);
+    this.name = 'InstallerError';
+    this.exitCode = exitCode;
+  }
+}
+
+/** A usage error: a wrong command line. Exit code 2. */
+export function usageError(message) {
+  return new InstallerError(`${message}. Run "npx pandite --help" for the options.`, { exitCode: 2 });
+}

package/lib/github.js

@@ -0,0 +1,109 @@
+// The Pandite releases on GitHub: the latest release, a named release, the
+// list of versions, and the SHA256SUMS.txt format. Anonymous requests only.
+
+import { InstallerError } from './errors.js';
+import { getText } from './net.js';
+import { RELEASES_URL, REPO } from './platform.js';
+import { compareVersions, parseVersion } from './version.js';
+
+export const API_URL = `https://api.github.com/repos/${REPO}`;
+const API_HEADERS = { accept: 'application/vnd.github+json', 'x-github-api-version': '2022-11-28' };
+const MAX_PAGES = 10;
+
+function retryText(headers, now) {
+  const after = Number.parseInt(headers.get('retry-after') ?? '', 10);
+  const reset = Number.parseInt(headers.get('x-ratelimit-reset') ?? '', 10);
+  let seconds = null;
+  if (after >= 0) seconds = after;
+  else if (reset > 0) seconds = reset - Math.floor(now() / 1000);
+  if (seconds === null) return 'later';
+  const minutes = Math.max(1, Math.ceil(seconds / 60));
+  return `in ${minutes} minute${minutes === 1 ? '' : 's'}`;
+}
+
+/** GET an API address: { json, headers }, or null for HTTP 404. */
+async function api(url, net) {
+  const got = await getText(url, net, API_HEADERS);
+  if (got.status === 200) {
+    try {
+      return { json: JSON.parse(got.text), headers: got.headers };
+    } catch {
+      throw new InstallerError(`GitHub sent an answer that is not JSON for ${url}`);
+    }
+  }
+  if (got.status === 404) return null;
+  const limited = got.headers.get('x-ratelimit-remaining') === '0' || got.headers.has('retry-after');
+  if ((got.status === 403 || got.status === 429) && limited) {
+    throw new InstallerError(
+      'the GitHub API rate limit for this network is used up (60 requests per hour without sign-in). ' +
+        `Try again ${retryText(got.headers, net.now ?? Date.now)}.`,
+    );
+  }
+  throw new InstallerError(`GitHub answered HTTP ${got.status} for ${url}`);
+}
+
+/** The version of a tag "v<version>", or null for another tag. */
+export function tagVersion(tag) {
+  const text = String(tag ?? '');
+  if (!text.startsWith('v')) return null;
+  return parseVersion(text.slice(1)) ? text.slice(1) : null;
+}
+
+function toRelease(json, latest) {
+  const version = tagVersion(json?.tag_name);
+  if (!version) throw new InstallerError(`the release tag "${json?.tag_name}" is not v<version>`);
+  const assets = (Array.isArray(json.assets) ? json.assets : []).map((a) => ({
+    name: String(a?.name ?? ''),
+    url: String(a?.browser_download_url ?? ''),
+    size: Number(a?.size) || 0,
+  }));
+  return { tag: json.tag_name, version, prerelease: Boolean(json.prerelease), latest, assets };
+}
+
+/**
+ * The release of `version` (without "v"), or the latest release when
+ * `version` is null: { tag, version, prerelease, latest, assets }.
+ */
+export async function getRelease(version, net) {
+  const url = version ? `${API_URL}/releases/tags/v${version}` : `${API_URL}/releases/latest`;
+  const got = await api(url, net);
+  if (!got) {
+    if (version) {
+      throw new InstallerError(`no Pandite release v${version} found at ${RELEASES_URL}. Run "npx pandite --list" for the versions.`);
+    }
+    throw new InstallerError(`no Pandite release found at ${RELEASES_URL}`);
+  }
+  return toRelease(got.json, !version);
+}
+
+function nextPage(link) {
+  const m = /<([^>]+)>;\s*rel="next"/.exec(link ?? '');
+  return m && m[1].startsWith('https://api.github.com/') ? m[1] : null;
+}
+
+/** Every published release version, newest first: [{ version, prerelease }]. */
+export async function listReleases(net) {
+  const found = new Map();
+  let url = `${API_URL}/releases?per_page=100`;
+  for (let page = 0; url && page < MAX_PAGES; page += 1) {
+    const got = await api(url, net);
+    if (!got) break;
+    for (const r of Array.isArray(got.json) ? got.json : []) {
+      const version = tagVersion(r?.tag_name);
+      if (!version || r.draft) continue;
+      found.set(version, { version, prerelease: Boolean(r.prerelease) });
+    }
+    url = nextPage(got.headers.get('link'));
+  }
+  return [...found.values()].sort((a, b) => compareVersions(b.version, a.version));
+}
+
+/** Parse sha256sum output: Map of file name to lowercase SHA-256. */
+export function parseSums(text) {
+  const sums = new Map();
+  for (const line of String(text).split(/\r?\n/)) {
+    const m = /^([0-9a-fA-F]{64}) [ *](.+?)\s*$/.exec(line);
+    if (m) sums.set(m[2], m[1].toLowerCase());
+  }
+  return sums;
+}