feat(installers): install shell completions and man pages (bat, fd, lsd, rg, watchexec, zoxide)

Install bash/fish/zsh completions from release archive into
pkg_src_dir/share/, and man pages into pkg_src_dir/share/man/man1/.

_common/brew.js

@@ -1,62 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-/**
- * Gets releases from 'brew'.
- *
- * @param {null} _
- * @param {string} formula
- * @returns {Promise<any>}
- */
-async function getDistributables(_, formula) {
-  if (!formula) {
-    return Promise.reject('missing formula for brew');
-  }
-
-  let resp;
-  try {
-    let url = `https://formulae.brew.sh/api/formula/${formula}.json`;
-    resp = await Fetcher.fetch(url, {
-      headers: { Accept: 'application/json' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch '${formula}' release data from 'brew': ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let body = JSON.parse(resp.body);
-
-  var ver = body.versions.stable;
-  var dl = (
-    body.bottle.stable.files.high_sierra || body.bottle.stable.files.catalina
-  ).url.replace(new RegExp(ver.replace(/\./g, '\\.'), 'g'), '{{ v }}');
-  return [
-    {
-      version: ver,
-      download: dl.replace(/{{ v }}/g, ver),
-    },
-  ].concat(
-    body.versioned_formulae.map(
-      /** @param {String} f */
-      function (f) {
-        var ver = f.replace(/.*@/, '');
-        return {
-          version: ver,
-          download: dl,
-        };
-      },
-    ),
-  );
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables(null, 'mariadb').then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

_common/fetcher.js

@@ -1,56 +0,0 @@
-'use strict';
-
-let Fetcher = module.exports;
-
-/**
- * @typedef ResponseSummary
- * @prop {Boolean} ok
- * @prop {Headers} headers
- * @prop {Number} status
- * @prop {String} body
- */
-
-/**
- * @param {String} url
- * @param {RequestInit} opts
- * @returns {Promise<ResponseSummary>}
- */
-Fetcher.fetch = async function (url, opts) {
-  let resp = await fetch(url, opts);
-  let summary = Fetcher.throwIfNotOk(resp);
-
-  return summary;
-};
-
-/**
- * @param {Response} resp
- * @returns {Promise<ResponseSummary>}
- */
-Fetcher.throwIfNotOk = async function (resp) {
-  let text = await resp.text();
-
-  if (!resp.ok) {
-    let headers = Array.from(resp.headers);
-    console.error('[Fetcher] error: Response Headers:', headers);
-    console.error('[Fetcher] error: Response Text:', text);
-    let err = new Error(`fetch was not ok`);
-    Object.assign({
-      status: 503,
-      code: 'E_FETCH_RELEASES',
-      response: {
-        status: resp.status,
-        headers: headers,
-        body: text,
-      },
-    });
-    throw err;
-  }
-
-  let summary = {
-    ok: resp.ok,
-    headers: resp.headers,
-    status: resp.status,
-    body: text,
-  };
-  return summary;
-};

_common/git-tag.js

@@ -1,218 +0,0 @@
-'use strict';
-
-require('dotenv').config({ path: '.env' });
-
-var Crypto = require('crypto');
-var util = require('util');
-var exec = util.promisify(require('child_process').exec);
-var Fs = require('node:fs/promises');
-var FsSync = require('node:fs');
-var Path = require('node:path');
-
-var repoBaseDir = process.env.REPO_BASE_DIR || '';
-if (!repoBaseDir) {
-  repoBaseDir = Path.resolve('./_repos');
-  // for stderr
-  console.error(`[Warn] REPO_BASE_DIR= not set, ${repoBaseDir}`);
-}
-
-var Repos = {};
-
-Repos.clone = async function (repoPath, gitUrl) {
-  let uuid = Crypto.randomUUID();
-  let tmpPath = `${repoPath}.${uuid}.tmp`;
-  let bakPath = `${repoPath}.${uuid}.dup`;
-  await exec(`git clone --bare --filter=tree:0 ${gitUrl} ${tmpPath}`);
-
-  try {
-    FsSync.accessSync(repoPath);
-    return;
-  } catch (e) {
-    if (e.code !== 'ENOENT') {
-      throw e;
-    }
-  }
-
-  // sync to avoid race conditions
-  try {
-    FsSync.renameSync(repoPath, bakPath);
-  } catch (e) {
-    if (e.code !== 'ENOENT') {
-      throw e;
-    }
-  }
-  FsSync.renameSync(tmpPath, repoPath);
-
-  await Fs.rm(bakPath, { force: true, recursive: true });
-};
-
-Repos.checkExists = async function (repoPath) {
-  let err = await Fs.access(repoPath).catch(Object);
-  if (!err) {
-    return true;
-  }
-
-  if (err.code !== 'ENOENT') {
-    throw err;
-  }
-  return false;
-};
-
-Repos.fetch = async function (repoPath) {
-  await exec(`git --git-dir=${repoPath} fetch`);
-};
-
-Repos.getTags = async function (repoPath) {
-  var { stdout } = await exec(`git --git-dir=${repoPath} tag`);
-  var rawTags = stdout.trim().split('\n');
-
-  let tags = [];
-  for (let tag of rawTags) {
-    // ex: v1, v2, v1.1, 1.1.0-rc
-    let maybeVersionRe = /^(v\d+|v?\d+\.\d+)/;
-    let maybeVersion = maybeVersionRe.test(tag);
-    if (maybeVersion) {
-      tags.push(tag);
-    }
-  }
-
-  tags = tags.reverse();
-  return tags;
-};
-
-Repos.getTipInfo = async function (repoPath) {
-  var { stdout } = await exec(
-    `git --git-dir=${repoPath} rev-parse --abbrev-ref HEAD`,
-  );
-  var branch = stdout.trim();
-
-  var info = await Repos.getCommitInfo(repoPath, 'HEAD');
-  info.commitish = branch;
-
-  return info;
-};
-
-Repos.getCommitInfo = async function (repoPath, commitish) {
-  var { stdout } = await exec(
-    `git --git-dir=${repoPath} log -1 --format="%h %H %ad %cd" --date=iso-strict ${commitish}`,
-  );
-  stdout = stdout.trim();
-  var commitParts = stdout.split(/\s+/g);
-  return {
-    commitish: commitish,
-    commit_id: `${commitParts[0]}`,
-    commit: `${commitParts[1]}`,
-    date: commitParts[2],
-    date_authored: commitParts[3],
-  };
-};
-
-/**
- * Lists GitHub Releases (w/ uploaded assets)
- *
- * @param request
- * @param {string} owner
- * @param {string} gitUrl
- * @returns {PromiseLike<any> | Promise<any>}
- */
-async function getDistributables(gitUrl) {
-  let all = {
-    releases: [],
-    download: '',
-  };
-
-  let repoName = gitUrl.split('/').pop();
-  repoName = repoName.replace(/\.git$/, '');
-
-  let repoPath = `${repoBaseDir}/${repoName}.git`;
-
-  let isCloned = await Repos.checkExists(repoPath);
-  if (!isCloned) {
-    await Repos.clone(repoPath, gitUrl);
-  } else {
-    await Repos.fetch(repoPath);
-  }
-
-  let commitInfos = [];
-  let tags = await Repos.getTags(repoPath);
-  for (let tag of tags) {
-    let commitInfo = await Repos.getCommitInfo(repoPath, tag);
-    Object.assign(commitInfo, { version: tag, channel: '' });
-    commitInfos.push(commitInfo);
-  }
-
-  {
-    let tipInfo = await Repos.getTipInfo(repoPath);
-    // "2024-01-01T00:00:00-05:00" => "2024-01-01T05:00:00"
-    let date = new Date(tipInfo.date);
-    // "2024-01-01T05:00:00" => "v2024.01.01-05.00.00"
-    let version = date.toISOString();
-    // strip '.000Z'
-    version = version.replace(/\.\d+Z/, '');
-    version = version.replace(/[:\-]/g, '.');
-    version = version.replace(/T/, '-');
-    Object.assign(tipInfo, { version: `v${version}`, channel: '' });
-    if (commitInfos.length > 1) {
-      tipInfo.channel = 'beta';
-    }
-    commitInfos.push(tipInfo);
-  }
-
-  let releases = [];
-  for (let commitInfo of commitInfos) {
-    let version = commitInfo.version.replace(/^v/, '');
-
-    let date = new Date(commitInfo.date);
-    let isoDate = date.toISOString();
-    isoDate = isoDate.replace(/\.\d+Z/, '');
-
-    // tags and HEAD qualify for '--branch <branchish>'
-    let branch = commitInfo.commitish;
-
-    let rel = {
-      name: `${repoName}-v${version}`,
-      version: version,
-      git_tag: branch,
-      git_commit_hash: commitInfo.commit_id,
-      lts: false,
-      channel: commitInfo.channel,
-      date: isoDate,
-      os: '*',
-      arch: '*',
-      ext: 'git',
-      download: gitUrl,
-    };
-
-    releases.push(rel);
-  }
-  all.releases = releases;
-
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  (async function main() {
-    let testRepos = [
-      // just a few tags, and a different HEAD
-      'https://github.com/tpope/vim-commentary.git',
-      // no tags, just HEAD
-      'https://github.com/ziglang/zig.vim.git',
-      // many, many tags
-      //'https://github.com/dense-analysis/ale.git',
-    ];
-    for (let url of testRepos) {
-      let all = await getDistributables(url);
-
-      all = require('../_webi/normalize.js')(all);
-      console.info(JSON.stringify(all, null, 2));
-    }
-  })()
-    .then(function () {
-      process.exit(0);
-    })
-    .catch(function (err) {
-      console.error(err);
-    });
-}

_common/gitea.js

@@ -1,47 +0,0 @@
-'use strict';
-
-var GitHubish = require('./githubish.js');
-
-/**
- * Lists Gitea Releases (w/ uploaded assets)
- *
- * @param {null} _ - deprecated
- * @param {String} owner
- * @param {String} repo
- * @param {String} baseurl
- * @param {String} [username]
- * @param {String} [token]
- */
-async function getDistributables(
-  _,
-  owner,
-  repo,
-  baseurl,
-  username = '',
-  token = '',
-) {
-  baseurl = `${baseurl}/api/v1`;
-  let all = await GitHubish.getDistributables({
-    owner,
-    repo,
-    baseurl,
-    username,
-    token,
-  });
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables(
-    null,
-    'root',
-    'pathman',
-    'https://git.rootprojects.org',
-    '',
-    '',
-  ).then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

_common/github-source.js

@@ -1,40 +0,0 @@
-'use strict';
-
-require('dotenv').config({ path: '.env' });
-
-let GitHubSource = module.exports;
-
-let GitHubishSource = require('./githubish-source.js');
-
-/**
- * @param {Object} opts
- * @param {String} opts.owner
- * @param {String} opts.repo
- * @param {String} [opts.baseurl]
- * @param {String} [opts.username]
- * @param {String} [opts.token]
- */
-GitHubSource.getDistributables = async function ({
-  owner,
-  repo,
-  baseurl = 'https://api.github.com',
-  username = process.env.GITHUB_USERNAME || '',
-  token = process.env.GITHUB_TOKEN || '',
-}) {
-  let all = await GitHubishSource.getDistributables({
-    owner,
-    repo,
-    baseurl,
-    username,
-    token,
-  });
-  return all;
-};
-
-if (module === require.main) {
-  GitHubSource.getDistributables(null, 'BeyondCodeBootcamp', 'DuckDNS.sh').then(
-    function (all) {
-      console.info(JSON.stringify(all, null, 2));
-    },
-  );
-}

_common/github.js

@@ -1,42 +0,0 @@
-'use strict';
-
-require('dotenv').config({ path: '.env' });
-
-let GitHubish = require('./githubish.js');
-
-/**
- * Lists GitHub Releases (w/ uploaded assets)
- *
- * @param {null} _ - deprecated
- * @param {String} owner
- * @param {String} repo
- * @param {String} [baseurl]
- * @param {String} [username]
- * @param {String} [token]
- */
-module.exports = async function (
-  _,
-  owner,
-  repo,
-  baseurl = 'https://api.github.com',
-  username = process.env.GITHUB_USERNAME || '',
-  token = process.env.GITHUB_TOKEN || '',
-) {
-  let all = await GitHubish.getDistributables({
-    owner,
-    repo,
-    baseurl,
-    username,
-    token,
-  });
-  return all;
-};
-
-let GitHub = module.exports;
-GitHub.getDistributables = module.exports;
-
-if (module === require.main) {
-  GitHub.getDistributables(null, 'BurntSushi', 'ripgrep').then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

_common/githubish-source.js

@@ -1,174 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-let GitHubishSource = module.exports;
-
-/**
- * Lists GitHub-Like Releases (source tarball & zip)
- *
- * @param {Object} opts
- * @param {String} opts.owner
- * @param {String} opts.repo
- * @param {String} opts.baseurl
- * @param {String} [opts.username]
- * @param {String} [opts.token]
- */
-GitHubishSource.getDistributables = async function ({
-  owner,
-  repo,
-  baseurl,
-  username = '',
-  token = '',
-}) {
-  if (!owner) {
-    throw new Error('missing owner for repo');
-  }
-  if (!repo) {
-    throw new Error('missing repo name');
-  }
-  if (!baseurl) {
-    throw new Error('missing baseurl');
-  }
-
-  let url = `${baseurl}/repos/${owner}/${repo}/releases`;
-  let opts = {
-    headers: {
-      'Content-Type': 'appplication/json',
-    },
-  };
-
-  if (token) {
-    let userpass = `${username}:${token}`;
-    let basicAuth = btoa(userpass);
-    Object.assign(opts.headers, {
-      Authorization: `Basic ${basicAuth}`,
-    });
-  }
-
-  let resp;
-  try {
-    resp = await Fetcher.fetch(url, opts);
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch '${baseurl}' (githubish-source, user '${username}) release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let gHubResp = JSON.parse(resp.body);
-
-  let all = {
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-    download: '',
-  };
-
-  for (let release of gHubResp) {
-    let dists = GitHubishSource.releaseToDistributables(release);
-    for (let dist of dists) {
-      let updates =
-        await GitHubishSource.followDistributableDownloadAttachment(dist);
-      Object.assign(dist, updates);
-      all.releases.push(dist);
-    }
-  }
-
-  return all;
-};
-
-/**
- * @typedef BuildInfo
- * @prop {String} [name] - name to use instead of filename for hash urls
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} [arch]
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} [ext]
- * @prop {String} [_filename]
- * @prop {String} [hash]
- * @prop {String} [libc]
- * @prop {Boolean} [_musl]
- * @prop {Boolean} [lts]
- * @prop {String} [size]
- * @prop {String} os
- */
-
-/**
- * @param {any} ghRelease - TODO
- * @returns {Array<BuildInfo>}
- */
-GitHubishSource.releaseToDistributables = function (ghRelease) {
-  let ghTag = ghRelease['tag_name']; // TODO tags aren't always semver / sensical
-  let lts = /(\b|_)(lts)(\b|_)/.test(ghRelease['tag_name']);
-  let channel = 'stable';
-  if (ghRelease['prerelease']) {
-    channel = 'beta';
-  }
-  let date = ghRelease['published_at'] || '';
-  date = date.replace(/T.*/, '');
-
-  let urls = [ghRelease.tarball_url, ghRelease.zipball_url];
-  /** @type {Array<BuildInfo>} */
-  let dists = [];
-  for (let url of urls) {
-    dists.push({
-      name: '',
-      version: ghTag,
-      lts: lts,
-      channel: channel,
-      date: date,
-      os: '*',
-      arch: '*',
-      libc: '',
-      ext: '',
-      download: url,
-    });
-  }
-
-  return dists;
-};
-
-/**
- * @param {BuildInfo} dist
- */
-GitHubishSource.followDistributableDownloadAttachment = async function (dist) {
-  let abortCtrl = new AbortController();
-  let resp = await fetch(dist.download, {
-    method: 'HEAD',
-    redirect: 'follow',
-    signal: abortCtrl.signal,
-  });
-  let headers = Object.fromEntries(resp.headers);
-
-  // Workaround for bug where METHOD changes to GET
-  abortCtrl.abort();
-  await resp.text().catch(function (err) {
-    if (err.name !== 'AbortError') {
-      throw err;
-    }
-  });
-
-  // ex: content-disposition: attachment; filename=BeyondCodeBootcamp-DuckDNS.sh-v1.0.1-0-ga2f4bde.zip
-  //  => BeyondCodeBootcamp-DuckDNS.sh-v1.0.1-0-ga2f4bde.zip
-  let name = headers['content-disposition'].replace(
-    /.*filename=([^;]+)(;|$)/,
-    '$1',
-  );
-  let download = resp.url;
-
-  return { name, download };
-};
-
-if (module === require.main) {
-  GitHubishSource.getDistributables({
-    owner: 'BeyondCodeBootcamp',
-    repo: 'DuckDNS.sh',
-    baseurl: 'https://api.github.com',
-  }).then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

_common/githubish.js

@@ -1,137 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-/**
- * @typedef DistributableRaw
- * @prop {String} name
- * @prop {String} version
- * @prop {Boolean} lts
- * @prop {String} [channel]
- * @prop {String} date
- * @prop {String} os
- * @prop {String} arch
- * @prop {String} ext
- * @prop {String} download
- */
-
-let GitHubish = module.exports;
-
-/**
- * Lists GitHub-Like Releases (w/ uploaded assets)
- *
- * @param {Object} opts
- * @param {String} opts.owner
- * @param {String} opts.repo
- * @param {String} opts.baseurl
- * @param {String} [opts.username]
- * @param {String} [opts.token]
- */
-GitHubish.getDistributables = async function ({
-  owner,
-  repo,
-  baseurl,
-  username = '',
-  token = '',
-}) {
-  if (!owner) {
-    throw new Error('missing owner for repo');
-  }
-  if (!repo) {
-    throw new Error('missing repo name');
-  }
-  if (!baseurl) {
-    throw new Error('missing baseurl');
-  }
-
-  let url = `${baseurl}/repos/${owner}/${repo}/releases`;
-  let opts = {
-    headers: {
-      'Content-Type': 'appplication/json',
-    },
-  };
-
-  if (token) {
-    let userpass = `${username}:${token}`;
-    let basicAuth = btoa(userpass);
-    Object.assign(opts.headers, {
-      Authorization: `Basic ${basicAuth}`,
-    });
-  }
-
-  let resp;
-  try {
-    resp = await Fetcher.fetch(url, opts);
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch '${baseurl}' (githubish, user '${username}) release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let gHubResp = JSON.parse(resp.body);
-
-  let all = {
-    /** @type {Array<DistributableRaw>} */
-    releases: [],
-    // todo make this ':baseurl' + ':releasename'
-    download: '',
-  };
-
-  try {
-    gHubResp.forEach(transformReleases);
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    console.error(err.message);
-    console.error('Error Headers:', resp.headers);
-    console.error('Error Body:', resp.body);
-    let msg = `failed to transform releases from '${baseurl}' with user '${username}'`;
-    throw new Error(msg);
-  }
-
-  /**
-   * @param {any} release - TODO
-   */
-  function transformReleases(release) {
-    for (let asset of release['assets']) {
-      let name = asset['name'];
-      let date = release['published_at']?.replace(/T.*/, '');
-      let download = asset['browser_download_url'];
-
-      // TODO tags aren't always semver / sensical
-      let version = release['tag_name'];
-      let channel;
-      if (release['prerelease']) {
-        // -rcX, -preview, -beta, etc will be checked in _webi/normalize.js
-        channel = 'beta';
-      }
-      let lts = /(\b|_)(lts)(\b|_)/.test(release['tag_name']);
-
-      all.releases.push({
-        name: name,
-        version: version,
-        lts: lts,
-        channel: channel,
-        date: date,
-        os: '', // will be guessed by download filename
-        arch: '', // will be guessed by download filename
-        ext: '', // will be normalized
-        download: download,
-      });
-    }
-  }
-
-  return all;
-};
-
-if (module === require.main) {
-  GitHubish.getDistributables({
-    owner: 'BurntSushi',
-    repo: 'ripgrep',
-    baseurl: 'https://api.github.com',
-  }).then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

_example/releases.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'BurntSushi';
-var repo = 'ripgrep';
-
-/******************************************************************************/
-/** Note: Delete this Comment!                                               **/
-/**                                                                          **/
-/** Need a an example that filters out miscellaneous release files?          **/
-/**   See `deno`, `gitea`, or `caddy`                                        **/
-/**                                                                          **/
-/******************************************************************************/
-
-let Releases = module.exports;
-
-Releases.latest = async function () {
-  let all = await github(null, owner, repo);
-  return all;
-};
-
-Releases.sample = async function () {
-  let normalize = require('../_webi/normalize.js');
-  let all = await Releases.latest();
-  all = normalize(all);
-  // just select the first 5 for demonstration
-  all.releases = all.releases.slice(0, 5);
-  return all;
-};
-
-if (module === require.main) {
-  (async function () {
-    let samples = await Releases.sample();
-
-    console.info(JSON.stringify(samples, null, 2));
-  })();
-}

_skills/installer/SKILL.md

@@ -1,442 +0,0 @@
----
-name: installer
-description: >
-  Create or update install.sh and install.ps1 scripts for a webi package.
-  Use when adding a new package to webi-installers, or when an existing
-  install script needs to be updated to match a changed archive structure.
-  Covers discovering archive layout from GitHub releases, identifying the
-  right install pattern (A–I), and writing both the POSIX shell and
-  PowerShell scripts that the webi framework calls.
-  Note: this skill covers install scripts only — writing releases.js /
-  releases.conf (the release-fetcher config) is a separate concern.
-license: MIT
-compatibility: Requires git, curl, tar. GitHub API access needed for
-  discovery phase. Designed for Claude Code in the webi-installers repo.
-metadata:
-  author: AJ ONeal
-  version: "1.1"
----
-
-# Webi Installer Skill
-
-Write `install.sh` and `install.ps1` for a webi package. These scripts are
-called by the webi framework **after** it has already downloaded and verified
-the archive — your job is only to unpack and place the files.
-
-> **Scope:** This skill covers `install.sh` and `install.ps1` only. A
-> separate `releases.js` / `releases.conf` file is needed to tell webi where
-> to fetch releases from. That config must already exist (or be written
-> separately) before these install scripts are useful.
-
-## Quick overview
-
-1. [Discover the archive layout](#1-discover-the-archive-layout) — inspect
-   GitHub releases with `curl` + `tar -t` to understand what's inside.
-2. [Choose the install pattern](#2-choose-the-install-pattern) — nine
-   patterns (A–I) cover almost every real-world case.
-3. [Write `install.sh`](#3-write-installsh) — POSIX shell, ~20–40 lines.
-4. [Write `install.ps1`](#4-write-installps1) — PowerShell, ~40–60 lines.
-5. [Check for classification issues](#5-check-for-classification-issues) —
-   look for variant assets, non-standard OS/arch naming, or installer .exe
-   files that need special handling.
-
-Full reference: [`references/PATTERNS.md`](references/PATTERNS.md)
-Archive layout details: [`references/ARCHIVE-LAYOUTS.md`](references/ARCHIVE-LAYOUTS.md)
-Classification guide: [`references/CLASSIFICATION.md`](references/CLASSIFICATION.md)
-
----
-
-## 1. Discover the archive layout
-
-### Use the webi releases API (fastest, if the package already exists)
-
-```sh
-# JSON with all releases for a package
-curl -s https://webinstall.dev/api/releases/bat.json | jq '.releases[:3]'
-```
-
-Each entry has `name` (filename), `version`, `os`, `arch`, `ext`, `download`.
-
-### Or inspect GitHub releases directly
-
-```sh
-# List asset filenames for the latest release
-curl -s "https://api.github.com/repos/sharkdp/bat/releases?per_page=3" \
-  | jq '.[0].assets[] | .name'
-```
-
-### Inspect what's inside an archive
-
-Download one representative asset and list its contents **without extracting**:
-
-```sh
-# tar.gz / tar.xz
-curl -fsSL "$DOWNLOAD_URL" | tar -tz
-
-# tar.zst (modern systems — GNU tar / bsdtar both support this)
-curl -fsSL "$DOWNLOAD_URL" | tar --zstd -tz
-
-# zip
-curl -fsSL "$DOWNLOAD_URL" -o /tmp/pkg.zip && unzip -l /tmp/pkg.zip
-
-# bare binary (no archive extension, e.g. jq-linux-amd64)
-# The file IS the binary — no unpacking needed. Set WEBI_SINGLE=true.
-```
-
-Look for:
-- Is the binary at the top level or inside a subdirectory?
-- Does the subdirectory name include the version and/or triplet?
-- Are there completions (`completions/`, `autocomplete/`, `complete/`)?
-- Are there man pages (`*.1`, `doc/*.1`, `man/man1/`)?
-- Are there shared libraries (`.so`, `.dylib`, `.dll`) alongside the binary?
-- Is the binary name different from the package command name?
-
-See [`references/ARCHIVE-LAYOUTS.md`](references/ARCHIVE-LAYOUTS.md) for
-what each pattern looks like, with real examples.
-
----
-
-## 2. Choose the install pattern
-
-| Pattern | Description | Examples |
-|---------|-------------|---------|
-| **A** | Bare binary (or binary+docs) at archive root | caddy, fzf, k9s, terraform |
-| **B** | Binary inside a version/triplet-named subdirectory | delta, shellcheck, trip, xsv |
-| **C** | Like B, plus shell completions and/or man pages | bat, fd, rg, sd, watchexec, zoxide |
-| **D** | Binary + shared libraries (bundled) | ollama (Linux), psql, sass, syncthing |
-| **E** | FHS-like layout (`bin/`, `share/man/`) | gh, pandoc |
-| **F** | Renamed binary needing install-time rename | pathman, yq |
-| **G** | Full SDK/toolchain (many files) | go, node, zig, flutter, julia |
-| **H** | .NET runtime bundle | pwsh |
-| **I** | Multi-binary distribution | dashcore, mutagen |
-
-**Pattern A** is by far the most common (~28 packages). When in doubt,
-download the archive and `tar -tz` it before writing a single line of code.
-
----
-
-## 3. Write `install.sh`
-
-The framework (`_webi/package-install.tpl.sh`) handles: user-agent detection,
-version resolution, download, checksum verification, and PATH management.
-Your script is **injected into** the framework and provides the
-package-specific part: where to find the binary and how to move it.
-
-### Script structure
-
-Every `install.sh` wraps its definitions in an `__init_pkgname()` function
-and immediately calls it. This prevents variable leakage when the script is
-sourced by the framework:
-
-```sh
-#!/bin/sh
-
-__init_toolname() {
-    set -e
-    set -u
-
-    ####################
-    # Install toolname #
-    ####################
-
-    pkg_cmd_name="toolname"
-    WEBI_SINGLE=true   # if applicable — see below
-
-    pkg_dst_cmd="$HOME/.local/bin/toolname"
-    pkg_dst="$pkg_dst_cmd"
-
-    pkg_src_cmd="$HOME/.local/opt/toolname-v$WEBI_VERSION/bin/toolname"
-    pkg_src_dir="$HOME/.local/opt/toolname-v$WEBI_VERSION"
-    pkg_src="$pkg_src_cmd"
-
-    pkg_install() {
-        # ...
-    }
-
-    pkg_get_current_version() {
-        # ...
-    }
-
-}
-
-__init_toolname
-```
-
-### Variables
-
-| Variable | Description |
-|----------|-------------|
-| `pkg_cmd_name` | The command name that ends up on `$PATH` |
-| `pkg_dst_cmd` | Final destination: `~/.local/bin/<cmd>` (the symlink) |
-| `pkg_dst` | Same as `pkg_dst_cmd` for single-binary packages; `~/.local/opt/<cmd>` for SDKs |
-| `pkg_src_cmd` | Versioned binary: `~/.local/opt/<pkg>-v<ver>/bin/<cmd>` |
-| `pkg_src_dir` | Versioned install dir: `~/.local/opt/<pkg>-v<ver>` |
-| `pkg_src` | Same as `pkg_src_cmd` for single-binary packages; same as `pkg_src_dir` for SDKs |
-
-**Framework-derived (set by the framework before calling `pkg_install` — do not set manually):**
-- `pkg_src_bin` — `$(dirname "$pkg_src_cmd")` — the versioned `bin/` dir
-- `pkg_dst_bin` — `$(dirname "$pkg_dst_cmd")` — `~/.local/bin`
-
-### `WEBI_SINGLE`
-
-`WEBI_SINGLE=true` affects the default values the framework uses for
-`pkg_src` and `pkg_dst`, and how `webi_link()` creates the symlink:
-
-- **With `WEBI_SINGLE=true`**: links the binary file directly:
-  `~/.local/bin/cmd → ~/.local/opt/cmd-vX.Y.Z/bin/cmd`
-- **Without it (default)**: links the directory:
-  `~/.local/opt/cmd → ~/.local/opt/cmd-vX.Y.Z`
-
-Set `WEBI_SINGLE=true` when using the conventional Pattern A skeleton
-(where `pkg_src` and `pkg_dst` are not set to custom values). When you
-explicitly assign all six variables yourself (as in Patterns B–F),
-`WEBI_SINGLE` is not strictly required but can still be set for clarity.
-
-Pattern G (SDKs) and Pattern H (.NET bundles) do NOT use `WEBI_SINGLE` —
-they define `pkg_link()` manually because the whole directory tree must
-be linked, not just a single binary.
-
-### Required function: `pkg_install`
-
-Moves files from the extracted archive into the versioned opt directory.
-The framework has already extracted the archive into a temp directory and
-`cd`'d into it before calling `pkg_install`.
-
-```sh
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./tool-*/tool "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-```
-
-### Recommended function: `pkg_get_current_version`
-
-Used to detect whether the package is already installed at the right version:
-
-```sh
-pkg_get_current_version() {
-    # 'tool --version' output: "tool 1.2.3 (rev abc)"
-    # trim to just the version number
-    tool --version 2>/dev/null | head -n 1 | cut -d' ' -f2
-}
-```
-
-### Skeletons by pattern
-
-**Pattern A** — binary at archive root (`WEBI_SINGLE=true`):
-```sh
-WEBI_SINGLE=true
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./"$pkg_cmd_name"* "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-```
-Use `$pkg_cmd_name*` as the glob — it matches the binary and avoids
-accidentally moving LICENSE or README into the binary path.
-
-**Pattern B** — binary inside a `tool-{ver}-{triplet}/` subdirectory:
-```sh
-WEBI_SINGLE=true
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./tool-*/tool "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-```
-
-**Pattern C** — like B, plus completions and man pages.
-The completion directory and filename vary per package — always check
-`tar -tz` output first. Common variants: `completions/`, `autocomplete/`,
-`complete/`. See [`references/PATTERNS.md`](references/PATTERNS.md) for
-a full example with guards:
-```sh
-WEBI_SINGLE=true
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./tool-*/tool "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-
-    # bash completion (directory name varies — check tar -tz)
-    if test -e ./tool-*/completions/tool.bash; then
-        mkdir -p "$pkg_src_dir/share/bash-completion/completions"
-        mv ./tool-*/completions/tool.bash \
-            "$pkg_src_dir/share/bash-completion/completions/tool"
-    fi
-    if test -e ./tool-*/completions/tool.fish; then
-        mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
-        mv ./tool-*/completions/tool.fish \
-            "$pkg_src_dir/share/fish/vendor_completions.d/tool.fish"
-    fi
-    if test -e ./tool-*/completions/_tool; then
-        mkdir -p "$pkg_src_dir/share/zsh/site-functions"
-        mv ./tool-*/completions/_tool \
-            "$pkg_src_dir/share/zsh/site-functions/_tool"
-    fi
-    if test -e ./tool-*/tool.1; then
-        mkdir -p "$pkg_src_dir/share/man/man1"
-        mv ./tool-*/tool.1 "$pkg_src_dir/share/man/man1/tool.1"
-    fi
-}
-```
-
-**Pattern D** — binary + shared libraries. The entire directory structure
-must be preserved. See [`references/PATTERNS.md`](references/PATTERNS.md)
-for the ollama and psql examples.
-
-**Pattern E** — FHS layout (archive already has `bin/` and `share/`):
-```sh
-WEBI_SINGLE=true
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    mv ./tool-*/ "$pkg_src_dir"
-}
-```
-
-**Pattern F** — binary needs rename (archive name ≠ command name).
-Use when the binary in the archive cannot be matched by `$pkg_cmd_name*`
-— e.g., `yq_linux_amd64` for a command named `yq`:
-```sh
-WEBI_SINGLE=true
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./yq_* "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-```
-
-**Pattern G** — full SDK (do NOT set `WEBI_SINGLE`):
-```sh
-# pkg_src = directory, not a binary
-pkg_src="$pkg_src_dir"
-pkg_dst="$HOME/.local/opt/tool"
-
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    mv ./tool-*/ "$pkg_src_dir"
-}
-
-pkg_link() {
-    rm -f "$pkg_dst"
-    ln -s "$pkg_src" "$pkg_dst"
-}
-```
-
----
-
-## 4. Write `install.ps1`
-
-A PowerShell framework template exists (`_webi/package-install.tpl.ps1`)
-and injects the `install.ps1` script at the `# {{ installer }}` placeholder.
-The template provides: error handling, directory setup, `Invoke-DownloadUrl`
-helper, and PATH management via `webi_path_add`. However, unlike the shell
-side, the PS1 framework does **not** download or extract the archive — the
-package script must handle that itself. The same path conventions apply
-(opt/bin layout), but Windows uses `Copy-Item` instead of symlinks for
-the final `bin/` step.
-
-### Variable block (always at top)
-
-```powershell
-$pkg_cmd_name = "tool"
-
-$pkg_dst_cmd = "$Env:USERPROFILE\.local\bin\tool.exe"
-$pkg_dst_bin = "$Env:USERPROFILE\.local\bin"
-$pkg_dst = "$pkg_dst_cmd"
-
-$pkg_src_cmd = "$Env:USERPROFILE\.local\opt\tool-v$Env:WEBI_VERSION\bin\tool.exe"
-$pkg_src_bin = "$Env:USERPROFILE\.local\opt\tool-v$Env:WEBI_VERSION\bin"
-$pkg_src_dir = "$Env:USERPROFILE\.local\opt\tool-v$Env:WEBI_VERSION"
-$pkg_src = "$pkg_src_cmd"
-```
-
-### Standard body
-
-```powershell
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
-$pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-
-# Fetch archive
-if (!(Test-Path -Path "$pkg_download")) {
-    Write-Output "Downloading tool from $Env:WEBI_PKG_URL to $pkg_download"
-    & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & Move-Item "$pkg_download.part" "$pkg_download"
-}
-
-if (!(Test-Path -Path "$pkg_src_cmd")) {
-    Write-Output "Installing tool"
-
-    Push-Location .local\tmp
-        Remove-Item -Path ".\tool-v*" -Recurse -ErrorAction Ignore
-
-        # Unpack — Windows BSD-tar handles zip too
-        Write-Output "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
-
-        # Move binary into place — adjust glob for your archive structure
-        Write-Output "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
-        Move-Item -Path ".\tool-*\tool.exe" -Destination "$pkg_src_bin"
-    Pop-Location
-}
-
-# Windows has no symlinks in the webi sense — copy to bin/
-Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
-New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
-Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
-```
-
-For Pattern A (binary at archive root), change the `Move-Item` line to:
-```powershell
-Move-Item -Path ".\tool.exe" -Destination "$pkg_src_bin"
-```
-
----
-
-## 5. Check for classification issues
-
-Before writing any scripts, scan the asset list for red flags:
-
-### Non-standard OS/arch names in filenames
-
-The webi classifier recognises most patterns automatically. Watch for:
-- `darwin` vs `macos` — both recognised; output normalised to `macos`
-- `x86_64` vs `amd64` — both recognised; output normalised to `amd64`
-- `aarch64` vs `arm64` — both recognised; output normalised to `arm64`
-- `armv7` (missing trailing `l`) — normalised to `armv7l`
-
-These are handled automatically. Only flag them if the asset list contains
-something genuinely unusual that the classifier would not recognise.
-
-### Variant assets needing tags
-
-Flag if you see multiple assets for the same OS/arch that serve different
-hardware or runtime requirements:
-- **GPU variants**: `*-rocm*`, `*-cuda*`, `*-vulkan*` alongside a baseline build
-- **Windows installer**: `*Setup.exe` or `*Install.exe` alongside a bare `*.exe`
-- **Framework-dependent .NET**: `*-fxdependent*` vs self-contained
-- **AppImage**: `*.AppImage` — not supported by the webi installer
-- **Electron/GUI app**: `*.dmg` or `*.AppImage` that is a full GUI app, not a CLI
-
-If you find variants, see [`references/CLASSIFICATION.md`](references/CLASSIFICATION.md)
-for how to write a variant tagger.
-
-### Formats to drop
-
-These are automatically filtered by the framework — no action needed:
-- `.deb`, `.rpm`, `.snap`, `.AppImage`
-- Checksums (`*.sha256`, `*.sha512`, `*.asc`, `*.sig`)
-- Source archives (`*-src.tar.gz`, `*.tar.gz` with no OS in name)
-
----
-
-## Reference files
-
-- [`references/PATTERNS.md`](references/PATTERNS.md) — detailed pattern
-  descriptions with real package examples and complete install script snippets
-- [`references/ARCHIVE-LAYOUTS.md`](references/ARCHIVE-LAYOUTS.md) — actual
-  `tar -t` output for representative packages in each pattern
-- [`references/CLASSIFICATION.md`](references/CLASSIFICATION.md) — when and
-  how to write variant taggers; non-standard filename conventions

_skills/installer/references/ARCHIVE-LAYOUTS.md

@@ -1,289 +0,0 @@
-# Archive Layouts — Real Package Examples
-
-Actual `tar -t` / `unzip -l` output for representative packages.
-Use these to calibrate your eye for what each pattern looks like.
-
----
-
-## Pattern A — Flat archive (no subdirectory)
-
-### caddy 2.9.1 — linux/amd64 tar.gz
-```
-caddy
-LICENSE
-README.md
-```
-Binary `caddy` is at the top level. Set `WEBI_SINGLE=true`.
-
-### fzf 0.70.0 — linux/amd64 tar.gz
-```
-fzf
-```
-Minimal — just the binary.
-
-### terraform 1.9.8 — linux/amd64 zip
-```
-terraform
-LICENSE.txt
-```
-Zip archive but same flat layout.
-
-### k9s — linux/amd64 tar.gz
-```
-k9s
-LICENSE
-README.md
-```
-
----
-
-## Pattern B — Named subdirectory, binary only
-
-### delta 0.18.2 — linux/amd64 tar.gz
-```
-delta-0.18.2-x86_64-unknown-linux-musl/
-delta-0.18.2-x86_64-unknown-linux-musl/delta
-delta-0.18.2-x86_64-unknown-linux-musl/LICENSE
-delta-0.18.2-x86_64-unknown-linux-musl/README.md
-```
-Glob to move: `./delta-*/delta`
-
-### shellcheck 0.10.0 — linux/x86_64 tar.xz
-```
-shellcheck-v0.10.0/
-shellcheck-v0.10.0/shellcheck
-shellcheck-v0.10.0/LICENSE.txt
-shellcheck-v0.10.0/README.txt
-```
-Glob to move: `./shellcheck-*/shellcheck`
-
-### xsv 0.13.0 — linux/x86_64 tar.gz
-```
-xsv-0.13.0-x86_64-unknown-linux-musl/
-xsv-0.13.0-x86_64-unknown-linux-musl/xsv
-xsv-0.13.0-x86_64-unknown-linux-musl/UNLICENSE
-```
-
----
-
-## Pattern C — Subdirectory + completions + man pages
-
-### rg/ripgrep 14.1.1 — linux/amd64 tar.gz
-```
-ripgrep-14.1.1-x86_64-unknown-linux-musl/
-ripgrep-14.1.1-x86_64-unknown-linux-musl/rg
-ripgrep-14.1.1-x86_64-unknown-linux-musl/complete/
-ripgrep-14.1.1-x86_64-unknown-linux-musl/complete/_rg
-ripgrep-14.1.1-x86_64-unknown-linux-musl/complete/_rg.ps1
-ripgrep-14.1.1-x86_64-unknown-linux-musl/complete/rg.bash
-ripgrep-14.1.1-x86_64-unknown-linux-musl/complete/rg.fish
-ripgrep-14.1.1-x86_64-unknown-linux-musl/doc/
-ripgrep-14.1.1-x86_64-unknown-linux-musl/doc/rg.1
-ripgrep-14.1.1-x86_64-unknown-linux-musl/doc/FAQ.md
-ripgrep-14.1.1-x86_64-unknown-linux-musl/doc/GUIDE.md
-ripgrep-14.1.1-x86_64-unknown-linux-musl/CHANGELOG.md
-ripgrep-14.1.1-x86_64-unknown-linux-musl/LICENSE-MIT
-ripgrep-14.1.1-x86_64-unknown-linux-musl/README.md
-```
-Note: completions are in `complete/` (not `completions/`). Man page is `doc/rg.1`.
-
-### sd 1.1.0 — linux/x86_64 tar.gz
-```
-sd-v1.1.0-x86_64-unknown-linux-musl/
-sd-v1.1.0-x86_64-unknown-linux-musl/sd
-sd-v1.1.0-x86_64-unknown-linux-musl/sd.1
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/sd.bash
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/sd.elv
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/sd.fish
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/_sd
-sd-v1.1.0-x86_64-unknown-linux-musl/completions/_sd.ps1
-sd-v1.1.0-x86_64-unknown-linux-musl/CHANGELOG.md
-sd-v1.1.0-x86_64-unknown-linux-musl/LICENSE
-sd-v1.1.0-x86_64-unknown-linux-musl/README.md
-```
-Note: man page `sd.1` is at subdirectory root. Completions in `completions/`.
-
-### bat 0.26.1 — linux/amd64 tar.gz
-```
-bat-v0.26.1-x86_64-unknown-linux-musl/
-bat-v0.26.1-x86_64-unknown-linux-musl/bat
-bat-v0.26.1-x86_64-unknown-linux-musl/bat.1
-bat-v0.26.1-x86_64-unknown-linux-musl/autocomplete/
-bat-v0.26.1-x86_64-unknown-linux-musl/autocomplete/bat.bash
-bat-v0.26.1-x86_64-unknown-linux-musl/autocomplete/bat.fish
-bat-v0.26.1-x86_64-unknown-linux-musl/autocomplete/bat.zsh
-bat-v0.26.1-x86_64-unknown-linux-musl/LICENSE-APACHE
-bat-v0.26.1-x86_64-unknown-linux-musl/LICENSE-MIT
-bat-v0.26.1-x86_64-unknown-linux-musl/README.md
-```
-Note: completions in `autocomplete/` (not `completions/`). Zsh file is `bat.zsh` not `_bat`.
-
-### goreleaser — linux/amd64 tar.gz
-```
-goreleaser
-completions/
-completions/goreleaser.bash
-completions/goreleaser.fish
-completions/goreleaser.zsh
-manpages/
-manpages/goreleaser.1.gz
-LICENSE.md
-README.md
-```
-Note: goreleaser uses Pattern A layout (binary at root, no subdirectory)
-but includes completions and a gzipped man page. Set `WEBI_SINGLE=true`;
-move completions and man page after the binary.
-
----
-
-## Pattern D — Binary + shared libraries
-
-### ollama 0.17.7 — linux/amd64 tar.zst
-```
-bin/
-bin/ollama
-lib/
-lib/ollama/
-lib/ollama/libggml-base.so
-lib/ollama/libggml-cpu-alderlake.so
-lib/ollama/libggml-cpu-haswell.so
-lib/ollama/libggml-cpu-icelake.so
-lib/ollama/libggml-cpu-sandybridge.so
-lib/ollama/libggml-cpu-skylakex.so
-lib/ollama/libggml-cpu-sse42.so
-lib/ollama/libggml-cpu-x64.so
-lib/ollama/cuda_v12/
-lib/ollama/cuda_v12/libcublas.so.12
-lib/ollama/cuda_v12/libcublasLt.so.12
-lib/ollama/cuda_v12/libcudart.so.12
-lib/ollama/cuda_v12/libggml-cuda.so
-... (66 files total)
-```
-Extract bin/ and lib/ directories separately or together.
-
-### psql (postgres client) — linux/amd64 tar.gz
-```
-psql-17.2-linux-x86_64/
-psql-17.2-linux-x86_64/bin/
-psql-17.2-linux-x86_64/bin/psql
-psql-17.2-linux-x86_64/lib/
-psql-17.2-linux-x86_64/lib/libpq.so.5
-psql-17.2-linux-x86_64/lib/libz.so.1
-psql-17.2-linux-x86_64/lib/libzstd.so.1
-psql-17.2-linux-x86_64/lib/libssl.so.3
-psql-17.2-linux-x86_64/lib/libcrypto.so.3
-psql-17.2-linux-x86_64/include/
-... (75 files total)
-```
-Move the entire `psql-{ver}-{triplet}/` directory: `mv ./psql-*/ "$pkg_src_dir"`
-
----
-
-## Pattern E — FHS layout
-
-### gh 2.67.0 — linux/amd64 tar.gz
-```
-gh_2.67.0_linux_amd64/
-gh_2.67.0_linux_amd64/bin/
-gh_2.67.0_linux_amd64/bin/gh
-gh_2.67.0_linux_amd64/share/
-gh_2.67.0_linux_amd64/share/man/
-gh_2.67.0_linux_amd64/share/man/man1/
-gh_2.67.0_linux_amd64/share/man/man1/gh-actions-cache-delete.1
-gh_2.67.0_linux_amd64/share/man/man1/gh-actions-cache-list.1
-... (129 man pages)
-gh_2.67.0_linux_amd64/LICENSE
-```
-Move the entire `gh_*/` directory: `mv ./gh_*/ "$pkg_src_dir"`
-
----
-
-## Pattern F — Binary needs rename
-
-### yq — linux/amd64 tar.gz (WEBI_SINGLE=true)
-```
-yq_linux_amd64
-yq.1
-```
-Binary is `yq_linux_amd64` — must rename to `yq` during install.
-
-### pathman 0.6.0 — linux/amd64 tar.gz (WEBI_SINGLE=true)
-```
-pathman-v0.6.0-linux-amd64_v1
-```
-Binary name includes the full release tag. Rename to `pathman`.
-
----
-
-## Pattern G — Full SDK
-
-### node 24.14.0 — linux/amd64 tar.xz
-```
-node-v24.14.0-linux-x64/
-node-v24.14.0-linux-x64/bin/
-node-v24.14.0-linux-x64/bin/node
-node-v24.14.0-linux-x64/bin/npm     -> ../lib/node_modules/npm/bin/npm-cli.js
-node-v24.14.0-linux-x64/bin/npx     -> ../lib/node_modules/npm/bin/npx-cli.js
-node-v24.14.0-linux-x64/include/
-node-v24.14.0-linux-x64/lib/
-node-v24.14.0-linux-x64/lib/node_modules/
-node-v24.14.0-linux-x64/share/
-... (thousands of files)
-```
-Move entire directory: `mv ./node-*/ "$pkg_src_dir"`
-
-### go 1.24.1 — linux/amd64 tar.gz
-```
-go/
-go/bin/
-go/bin/go
-go/bin/gofmt
-go/src/
-go/pkg/
-... (thousands of files)
-```
-Note: go's archive root directory is literally `go/` with no version in the name.
-
----
-
-## Pattern H — .NET runtime bundle
-
-### pwsh 7.4.6 — linux/amd64 tar.gz
-```
-pwsh
-Accessibility.dll
-clrcompression.dll
-clrjit.dll
-createdump
-cs/
-cs/System.Private.CoreLib.resources.dll
-de/
-de/System.Private.CoreLib.resources.dll
-... (727 files, all in same flat directory)
-```
-No subdirectory. Move all files into `$pkg_src_bin/`.
-
----
-
-## Inspecting archives yourself
-
-```sh
-# tar.gz / tar.xz / tar.zst — list contents only (no extraction)
-curl -fsSL "$URL" | tar -tz | head -20
-
-# zip
-curl -fsSL "$URL" -o /tmp/pkg.zip
-unzip -l /tmp/pkg.zip | head -20
-
-# For a .zst file when tar doesn't support zstd natively:
-curl -fsSL "$URL" -o /tmp/pkg.tar.zst && zstd -dc /tmp/pkg.tar.zst | tar -tz | head -20
-```
-
-**What to look for**:
-1. Is there a top-level directory? (Pattern B/C/D/E/G) or no directory? (Pattern A/F/H)
-2. What is the directory named? Does it contain version? triplet?
-3. Are there `completions/`, `autocomplete/`, `complete/` subdirs? (Pattern C)
-4. Are there `.so`/`.dylib`/`.dll` files? (Pattern D or H)
-5. Does the binary name match the command you want on PATH? (Pattern F if not)
-6. Is there a `bin/` directory at the top level? (Pattern E or G)

_skills/installer/references/CLASSIFICATION.md

@@ -1,183 +0,0 @@
-# Classification Reference
-
-When to flag classification issues, what the webi classifier does automatically,
-and what needs manual annotation.
-
----
-
-## What the classifier handles automatically
-
-The webi classifier (`internal/classify/classify.go`) parses asset filenames
-using regex patterns and produces canonical `os`, `arch`, `libc`, and `ext`
-values. It handles the vast majority of packages with no configuration needed.
-
-### OS recognition
-Filenames containing these terms are classified automatically:
-- `darwin`, `macos`, `osx`, `apple` → `macos` in legacy cache
-- `linux` → `linux`
-- `windows`, `win`, `win32`, `win64` → `windows`
-- `freebsd`, `openbsd`, `netbsd`, `dragonfly` → respective values
-- `.deb`, `.rpm`, `.snap` → `linux` (but dropped from legacy cache)
-- `.dmg`, `.app.zip` → `macos`
-
-### Arch recognition
-Filenames containing these terms are classified automatically:
-- `x86_64`, `amd64`, `64bit`, `x64` → `amd64`
-- `aarch64`, `arm64` → `arm64`
-- `armv7`, `armv7l`, `armhf`, `gnueabihf` → `armv7l`
-- `armv6`, `armv6l` → `armv6l`
-- `i386`, `i686`, `386`, `x86` → `x86`
-- `universal`, `universal2` → `amd64` (fat binary; arm64 falls back to this)
-
-### Format recognition
-- `.tar.gz`, `.tar.xz`, `.tar.zst`, `.tar.bz2`, `.zip`, `.7z` → compressed archive
-- `.pkg`, `.msi`, `.dmg` → platform installer
-- `.exe` → either bare binary or GUI installer (see below)
-- No extension in filename → bare binary (ext = `exe` in cache)
-
-### Automatically dropped
-These asset types are recognised and excluded without any configuration:
-- Checksums: `*.sha256`, `*.sha512`, `*.md5`, `*.sha256sum`
-- Signatures: `*.asc`, `*.sig`, `*.cosign`, `*.sbom`
-- Source archives: files with `source`, `src` in the name but no OS
-- Package formats not supported by the Node installer: `.deb`, `.rpm`, `.snap`,
-  `.AppImage`, `.apk`
-
----
-
-## When you need to add configuration
-
-### Variant assets
-
-A **variant** is a secondary build that serves the same OS/arch as a baseline
-build but requires different hardware or runtime support. The Node.js installer
-can't choose between variants — it only knows OS, arch, and libc. Variants
-must be tagged and then excluded at export time.
-
-**Common variants and how to identify them**:
-
-| Variant | Filename pattern | Notes |
-|---------|-----------------|-------|
-| CUDA (GPU) | `*-cuda*`, `*cuda12*` | NVIDIA GPU support |
-| ROCm (GPU) | `*-rocm*` | AMD GPU support |
-| Vulkan | `*-vulkan*` | Cross-vendor GPU |
-| AppImage | `*.AppImage` | Linux sandboxed app |
-| .NET fxdependent | `*-fxdependent*` | Requires .NET runtime |
-| Windows installer | `*Setup.exe`, `*Install.exe` | GUI installer, not the binary |
-
-**Rule**: if there are multiple assets for the same OS/arch combination and
-they serve the same users differently, they need variant tags. The baseline
-(most widely compatible) build should be kept; variants should be tagged and
-excluded.
-
-**Example**: ollama publishes for linux/amd64:
-- `ollama-linux-amd64.tar.zst` — baseline (CPU + any GPU auto-detected)
-- `ollama-linux-amd64-rocm.tar.zst` — ROCm variant
-- `ollama-linux-amd64-jetpack6.tar.zst` — NVIDIA Jetson variant
-
-Only the baseline is useful via webi. The ROCm and Jetpack builds should be
-tagged as variants and excluded.
-
----
-
-### Windows .exe: bare binary vs GUI installer
-
-`.exe` assets are ambiguous — they could be:
-1. A bare binary (the tool itself, run from command line)
-2. A GUI installer (runs a setup wizard, not useful for webi)
-
-**How to tell**:
-- GUI installer: filename contains `Setup`, `Install`, `Installer`, `inno`, `nsis`
-- GUI installer: the tool also has a `.zip` or `.tar.gz` for Windows
-- Bare binary: filename matches the tool name with minimal decoration
-
-**When you see both**, the `.zip`/archive build is what webi uses. The `.exe`
-installer should be tagged as a variant (`installer`) so it's excluded.
-
-**When there's only a `.exe`** (no archive), it's probably the bare binary.
-Test by downloading and running it — a bare binary runs immediately.
-
----
-
-### Packages with no OS/arch in filenames
-
-Some packages (rare) release with minimal filename decoration. Examples:
-- `tool-v1.2.3.tar.gz` — no OS, no arch
-- `tool.tar.gz` — version not even in filename
-
-These are usually source archives (not compiled binaries) and should be
-dropped entirely from the release list. If they are compiled binaries for a
-specific OS, the releases.js config needs an `asset_filter` key to match the
-right file, plus OS/arch metadata added.
-
----
-
-### Non-standard OS naming in filenames
-
-A few upstreams use unusual OS names:
-- `sunos` — should map to `solaris` (the webi classifier does this)
-- `osx` or `macosx` — recognised as `macos`
-- `apple-darwin` (Rust triplet) — recognised as `macos`
-
-If a package uses a genuinely unknown OS string, the classifier will produce
-`os = ""` for that asset. Those entries are dropped from the legacy cache.
-
----
-
-### Asset filter configuration
-
-If GitHub releases for a package include multiple builds that would otherwise
-collide (e.g. `extended` vs non-extended for hugo, or specific project builds
-in a monorepo), add to the package's `releases.conf`:
-
-```ini
-# Only include assets containing "extended" in the name
-asset_filter = extended
-
-# Exclude assets containing "legacy" in the name
-asset_exclude = legacy
-```
-
-These filters run before classification.
-
----
-
-## Quick checklist when inspecting a new package
-
-1. **Look at the latest 2–3 releases** on GitHub. Note all asset filenames.
-2. **Find the "standard" builds** — the ones a normal user would download for
-   their OS. Usually there are ≤4 per OS (amd64, arm64, x86, armv7l).
-3. **Check for extras**:
-   - Are there GPU-specific builds for the same OS/arch? → variant
-   - Are there `.exe` installer files alongside a `.zip`? → variant
-   - Are there `.deb`/`.rpm`/`.AppImage`? → auto-dropped, no action needed
-   - Does the Windows build have no archive and only a bare `.exe`? → fine
-4. **Check OS/arch naming** — does the filename use standard terms, or
-   something unusual that might confuse the classifier?
-5. **Check format changes** — do old releases use a different archive type
-   or directory layout than recent ones? The install script may need to
-   handle both.
-
----
-
-## Canonical vocabulary reference
-
-All cache output must use exactly these values.
-
-**OS**: `macos`, `linux`, `windows`, `freebsd`, `openbsd`, `netbsd`,
-`dragonfly`, `aix`, `illumos`, `plan9`, `solaris`
-
-**Arch**:
-- `amd64` (not `x86_64`)
-- `arm64` (not `aarch64`)
-- `armv7l` (not `armv7` — the `l` stands for little-endian; `uname -m` reports `armv7l`)
-- `armv6l` (not `armv6`)
-- `x86` (not `i386`, `i686`, `386`)
-- `mipsle` (not `mipsel`)
-- `mips64le` (not `mips64el`)
-- Other: `arm`, `ppc64le`, `ppc64`, `loong64`, `riscv64`, `s390x`, `mips`, `mips64`
-
-**Libc**: `none` (static/Go/Zig — never empty), `gnu`, `musl`, `msvc`
-
-**Ext**: `tar.gz`, `tar.xz`, `zip`, `exe`, `7z`, `pkg`, `msi`
-(no leading dot; `exe` for bare binaries with no file extension)

_skills/installer/references/PATTERNS.md

@@ -1,388 +0,0 @@
-# Install Patterns Reference
-
-Nine patterns cover the full range of webi packages. Pattern A is by far
-the most common. Check `tar -tz $ARCHIVE` before writing any code.
-
----
-
-## Pattern A — Bare binary at archive root
-
-The archive extracts directly to the current directory with no wrapper
-subdirectory. Binary (and optional LICENSE/README) is at the top level.
-
-**Set `WEBI_SINGLE=true`** — tells the framework to link the binary file
-directly (`~/.local/bin/cmd → ~/.local/opt/cmd-vX/bin/cmd`) rather than
-linking the versioned directory.
-
-Representative packages: caddy, fzf, k9s, terraform, sttr, lf, monorel,
-awless, bun, cilium, curlie, dashmsg, dotenv, dotenv-linter, ffuf,
-gitdeploy, gprox, grype, hugo, keypairs, koji, ots, runzip, sclient,
-sqlc, sqlpkg, uuidv7, xcaddy, deno
-
-**install.sh**:
-```sh
-pkg_cmd_name="caddy"
-WEBI_SINGLE=true
-
-pkg_dst_cmd="$HOME/.local/bin/caddy"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/caddy-v$WEBI_VERSION/bin/caddy"
-pkg_src_dir="$HOME/.local/opt/caddy-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./"$pkg_cmd_name"* "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-
-pkg_get_current_version() {
-    caddy version 2>/dev/null | head -n 1 | cut -d' ' -f1 | sed 's:^v::'
-}
-```
-
-**install.ps1** key lines:
-```powershell
-# No subdirectory — binary is at the top level of the archive
-Move-Item -Path ".\caddy.exe" -Destination "$pkg_src_bin"
-```
-
----
-
-## Pattern B — Binary inside a version/triplet subdirectory
-
-Archive extracts to a single directory named with the version and/or
-platform triplet. Binary (and docs) live inside that directory.
-
-Representative packages: delta, hexyl, shellcheck, trip, xsv, kubectx, kubens
-
-**Subdirectory naming conventions seen in the wild**:
-- `tool-{ver}-{triplet}/` — most Rust tools (delta, shellcheck, xsv)
-- `tool-{ver}/` — simpler version-only dirs
-- flat (no dir) — kubectx/kubens use flat archives despite being "B-ish"
-
-**install.sh**:
-```sh
-pkg_cmd_name="delta"
-# WEBI_SINGLE not set (or false)
-
-pkg_dst_cmd="$HOME/.local/bin/delta"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/delta-v$WEBI_VERSION/bin/delta"
-pkg_src_dir="$HOME/.local/opt/delta-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./delta-*/delta "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-
-pkg_get_current_version() {
-    delta --version 2>/dev/null | head -n 1 | cut -d' ' -f2
-}
-```
-
-**install.ps1** key lines:
-```powershell
-Move-Item -Path ".\delta-*\delta.exe" -Destination "$pkg_src_bin"
-```
-
----
-
-## Pattern C — Subdirectory with binary + completions and/or man pages
-
-Same as B but the archive also contains shell completions and/or man pages
-worth installing.
-
-Representative packages: bat, fd, lsd, rg/ripgrep, sd, watchexec, zoxide
-
-Note: goreleaser has a flat archive (Pattern A layout) but with completions at
-the archive root. See the goreleaser entry in ARCHIVE-LAYOUTS.md.
-
-**Completion directory name varies by package**:
-- `completions/` — sd, watchexec, zoxide
-- `autocomplete/` — bat, fd, lsd
-- `complete/` — rg/ripgrep
-
-**Completion filename conventions**:
-- Bash: `tool.bash`, `tool.bash-completion`, `_tool.bash`
-- Fish: `tool.fish`
-- Zsh: `_tool`
-- PowerShell: `_tool.ps1`, `tool.ps1`
-
-**Man page location varies**:
-- `tool.1` at subdirectory root — sd, bat, fd, lsd
-- `doc/tool.1` — rg/ripgrep
-- `man/man1/tool.1` — zoxide (deepest path)
-
-**install.sh** (rg as example):
-```sh
-pkg_cmd_name="rg"
-
-pkg_dst_cmd="$HOME/.local/bin/rg"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/rg-v$WEBI_VERSION/bin/rg"
-pkg_src_dir="$HOME/.local/opt/rg-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    mv ./ripgrep-*/rg "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-
-    # bash completion
-    if test -e ./ripgrep-*/complete/rg.bash; then
-        mkdir -p "$pkg_src_dir/share/bash-completion/completions"
-        mv ./ripgrep-*/complete/rg.bash \
-            "$pkg_src_dir/share/bash-completion/completions/rg"
-    fi
-    # fish completion
-    if test -e ./ripgrep-*/complete/rg.fish; then
-        mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
-        mv ./ripgrep-*/complete/rg.fish \
-            "$pkg_src_dir/share/fish/vendor_completions.d/rg.fish"
-    fi
-    # zsh completion
-    if test -e ./ripgrep-*/complete/_rg; then
-        mkdir -p "$pkg_src_dir/share/zsh/site-functions"
-        mv ./ripgrep-*/complete/_rg \
-            "$pkg_src_dir/share/zsh/site-functions/_rg"
-    fi
-    # man page
-    if test -e ./ripgrep-*/doc/rg.1; then
-        mkdir -p "$pkg_src_dir/share/man/man1"
-        mv ./ripgrep-*/doc/rg.1 "$pkg_src_dir/share/man/man1/rg.1"
-    fi
-}
-
-pkg_get_current_version() {
-    rg --version 2>/dev/null | head -n 1 | cut -d' ' -f2
-}
-```
-
-**Note**: Completion paths in completions/man install are best-effort
-— use `if test -e ...` guards so the script still works on older releases
-that didn't include them.
-
----
-
-## Pattern D — Binary + shared libraries
-
-The package bundles shared libraries alongside the binary. The entire
-directory tree must be preserved.
-
-Representative packages: ollama (Linux), psql/postgres, sass (Dart VM),
-syncthing, xz
-
-**install.sh**:
-```sh
-pkg_cmd_name="ollama"
-
-pkg_dst_cmd="$HOME/.local/bin/ollama"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/ollama-v$WEBI_VERSION/bin/ollama"
-pkg_src_dir="$HOME/.local/opt/ollama-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    # Archive already has bin/ and lib/ layout
-    mv ./bin "$pkg_src_dir/bin"
-    mv ./lib "$pkg_src_dir/lib"
-}
-```
-
-For psql (archive has a `psql-{ver}-{triplet}/` wrapper dir):
-```sh
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    mv ./psql-*/ "$pkg_src_dir"
-}
-```
-
----
-
-## Pattern E — FHS-like layout
-
-Archive already follows `bin/`, `share/man/`, `share/doc/` hierarchy.
-Extract the whole thing directly into the versioned opt directory.
-
-Representative packages: gh (GitHub CLI), pandoc
-
-**install.sh**:
-```sh
-pkg_cmd_name="gh"
-
-pkg_dst_cmd="$HOME/.local/bin/gh"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/gh-v$WEBI_VERSION/bin/gh"
-pkg_src_dir="$HOME/.local/opt/gh-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    mv ./gh_*/ "$pkg_src_dir"
-}
-
-pkg_get_current_version() {
-    gh --version 2>/dev/null | head -n 1 | cut -d' ' -f3
-}
-```
-
-No `chmod` needed — binary is already executable inside the archive.
-
----
-
-## Pattern F — Binary needs rename
-
-Binary in the archive doesn't match the expected command name.
-
-Representative packages: pathman (`pathman-v0.6.0-linux-amd64_v1` → `pathman`),
-yq (`yq_linux_amd64` → `yq`)
-
-**install.sh**:
-```sh
-pkg_cmd_name="yq"
-WEBI_SINGLE=true
-
-pkg_dst_cmd="$HOME/.local/bin/yq"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/yq-v$WEBI_VERSION/bin/yq"
-pkg_src_dir="$HOME/.local/opt/yq-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$pkg_src_bin"
-    # Binary is named yq_linux_amd64 (or yq_darwin_amd64 etc)
-    mv ./yq_* "$pkg_src_cmd"
-    chmod a+x "$pkg_src_cmd"
-}
-```
-
----
-
-## Pattern G — Full SDK / toolchain
-
-Archive contains a complete runtime or SDK (hundreds to thousands of files).
-The entire tree goes into opt; multiple binaries are linked from `bin/`.
-
-Representative packages: go, node, zig, flutter, julia, cmake, tinygo
-
-**install.sh** (node as example):
-```sh
-pkg_cmd_name="node"
-# NOTE: pkg_src points to the directory, not a binary
-
-pkg_dst_cmd="$HOME/.local/bin/node"
-pkg_dst="$HOME/.local/opt/node"   # versioned-dir symlink target
-
-pkg_src_cmd="$HOME/.local/opt/node-v$WEBI_VERSION/bin/node"
-pkg_src_dir="$HOME/.local/opt/node-v$WEBI_VERSION"
-pkg_src="$pkg_src_dir"            # pkg_src = the directory
-
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src")"
-    mv ./node-*/ "$pkg_src"
-}
-
-pkg_link() {
-    rm -f "$pkg_dst"
-    ln -s "$pkg_src" "$pkg_dst"
-}
-
-pkg_get_current_version() {
-    node --version 2>/dev/null | head -n 1 | sed 's:^v::'
-}
-```
-
----
-
-## Pattern H — .NET runtime bundle
-
-Flat directory with one binary and hundreds of `.dll` files. The entire
-directory must be preserved. Like Pattern G (SDK) in structure — the
-versioned directory is the package root, with the binary directly inside
-(no `bin/` subdirectory). A `pkg_link()` creates the unversioned symlink.
-
-Representative packages: pwsh (PowerShell Core)
-
-**install.sh**:
-```sh
-pkg_cmd_name="pwsh"
-
-# note: binary is at pkg_src_dir root, no bin/ subdirectory
-pkg_src_cmd="$HOME/.local/opt/pwsh-v$WEBI_VERSION/pwsh"
-pkg_src_dir="$HOME/.local/opt/pwsh-v$WEBI_VERSION"
-pkg_src="$pkg_src_dir"
-
-pkg_dst_cmd="$HOME/.local/opt/pwsh/pwsh"
-pkg_dst="$HOME/.local/opt/pwsh"
-
-pkg_install() {
-    # Archive extracts flat — move all contents into the versioned dir
-    mkdir -p "$pkg_src_dir"
-    mv ./* "$pkg_src_dir"
-    chmod a+x "$pkg_src_cmd"
-}
-
-pkg_link() {
-    rm -rf "$pkg_dst"
-    ln -s "$pkg_src" "$pkg_dst"
-}
-```
-
----
-
-## Pattern I — Multi-binary distribution
-
-Archive contains multiple related binaries. Install the primary one and
-link only that.
-
-Representative packages: dashcore (dashd + dash-cli + dash-qt + ...),
-mutagen (mutagen + mutagen-agents.tar.gz)
-
-**install.sh** (dashcore-style):
-```sh
-pkg_cmd_name="dashd"
-
-pkg_dst_cmd="$HOME/.local/bin/dashd"
-pkg_dst="$pkg_dst_cmd"
-pkg_src_cmd="$HOME/.local/opt/dashcore-v$WEBI_VERSION/bin/dashd"
-pkg_src_dir="$HOME/.local/opt/dashcore-v$WEBI_VERSION"
-pkg_src="$pkg_src_cmd"
-
-pkg_install() {
-    mkdir -p "$(dirname "$pkg_src_dir")"
-    mv ./dashcore-*/ "$pkg_src_dir"
-}
-```
-
----
-
-## Choosing between patterns
-
-```
-Archive root contains a single binary (or binary + docs)?
-  → Pattern A  (set WEBI_SINGLE=true)
-
-Archive has a named subdirectory wrapping the binary?
-  ├─ Binary only inside subdir?         → Pattern B
-  ├─ Binary + completions/man pages?    → Pattern C
-  └─ Binary + shared libraries (.so)?  → Pattern D
-
-Archive already has bin/ and share/ layout?
-  → Pattern E
-
-Binary name doesn't match the command name?
-  → Pattern F  (rename during install)
-
-Archive is a full SDK (compiler, runtime, stdlib)?
-  → Pattern G  (pkg_src = pkg_src_dir)
-
-Flat directory with many DLLs (.NET)?
-  → Pattern H
-
-Multiple binaries for a single distributed system?
-  → Pattern I
-```

_webi/builds-cacher-test.js

@@ -13,7 +13,6 @@ async function main() {
     caches: CACHE_DIR,
     installers: INSTALLERS_DIR,
   });
-  bc.freshenRandomPackage(600 * 1000);
 
   // let dirs = await bc.getProjectsByType();
   // let projNames = Object.keys(dirs.valid);

_webi/builds-cacher.js

@@ -3,13 +3,16 @@
 var BuildsCacher = module.exports;
 
 let Fs = require('node:fs/promises');
+let Os = require('node:os');
 let Path = require('node:path');
 
+let LEGACY_CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
+
 let HostTargets = require('./build-classifier/host-targets.js');
 let Lexver = require('./build-classifier/lexver.js');
 let Triplet = require('./build-classifier/triplet.js');
 
-var ALIAS_RE = /^alias: (\w+)$/m;
+var ALIAS_RE = /^alias: ([\w.-]+)$/m;
 
 var LEGACY_ARCH_MAP = {
   '*': 'ANYARCH',
@@ -126,61 +129,8 @@ async function readFirstBytes(path) {
   return str;
 }
 
-let promises = {};
-async function getLatestBuilds(Releases, installersDir, cacheDir, name, date) {
-  console.info(`[INFO] getLatestBuilds: ${name}`);
-
-  if (!Releases) {
-    Releases = require(`${installersDir}/${name}/releases.js`);
-  }
-  // TODO update all releases files with module.exports.xxxx = 'foo';
-  if (!Releases.latest) {
-    Releases.latest = Releases;
-  }
-
-  let id = `${cacheDir}/${name}`;
-  if (!promises[id]) {
-    promises[id] = Promise.resolve();
-  }
-
-  promises[id] = promises[id].then(async function () {
-    return await getLatestBuildsInner(Releases, cacheDir, name, date);
-  });
-
-  return await promises[id];
-}
-
-async function getLatestBuildsInner(Releases, cacheDir, name, date) {
-  let data = await Releases.latest();
-
-  if (!date) {
-    date = new Date();
-  }
-  let isoDate = date.toISOString();
-  let yearMonth = isoDate.slice(0, 7);
-
-  // TODO hash file
-  let dataFile = `${cacheDir}/${yearMonth}/${name}.json`;
-  // TODO fsstat releases.js vs require-ing time as well
-  let tsFile = `${cacheDir}/${yearMonth}/${name}.updated.txt`;
-
-  let dirPath = Path.dirname(dataFile);
-  await Fs.mkdir(dirPath, { recursive: true });
-
-  let json = JSON.stringify(data, null, 2);
-  await Fs.writeFile(dataFile, json, 'utf8');
-
-  let seconds = date.valueOf();
-  let ms = seconds / 1000;
-  let msStr = ms.toFixed(3);
-  await Fs.writeFile(tsFile, msStr, 'utf8');
-
-  return data;
-}
-
-BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
+BuildsCacher.create = function ({ ALL_TERMS, installers }) {
   let installersDir = installers;
-  let cacheDir = caches;
 
   if (!ALL_TERMS) {
     ALL_TERMS = Triplet.TERMS_PRIMARY_MAP;
@@ -195,9 +145,11 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
   bc._triplets = {};
   bc._targetsByBuildIdCache = {};
   bc._caches = {};
-  bc._staleAge = 15 * 60 * 1000;
   bc._allFormats = {};
   bc._allTriplets = {};
+  // Per-name lock: serializes cold-cache getPackages so concurrent
+  // callers can't corrupt bc._caches[name] via a transformAndUpdate race.
+  bc._inflight = {};
 
   for (let term of TERMS_META) {
     delete bc.orphanTerms[term];
@@ -216,19 +168,6 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     let entries = await Fs.readdir(installersDir, { withFileTypes: true });
     for (let entry of entries) {
       let meta = await bc.getProjectTypeByEntry(entry);
-      if (meta.type === 'not_found') {
-        let err = meta.detail;
-        console.error('');
-        console.error('PROBLEM');
-        console.error(`    ${err.message}`);
-        console.error('');
-        console.error('SOLUTION');
-        console.error('    npm clean-install');
-        console.error('');
-        throw new Error(
-          '[SANITY FAIL] should never have missing modules in prod',
-        );
-      }
       dirs[meta.type][entry.name] = meta.detail;
     }
 
@@ -297,19 +236,16 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
       return { type: 'alias', detail: link };
     }
 
-    let releasesPath = Path.join(path, 'releases.js');
-    try {
-      void require(releasesPath);
-    } catch (err) {
-      if (err.code !== 'MODULE_NOT_FOUND') {
-        return { type: 'errors', detail: err };
-      }
-
-      if (err.message.includes(`Cannot find module '${releasesPath}'`)) {
-        return { type: 'selfhosted', detail: true };
-      }
-
-      return { type: 'not_found', detail: err };
+    let cacheFile = `${LEGACY_CACHE_DIR}/${entry.name}.json`;
+    let hasCacheFile = await Fs.access(cacheFile)
+      .then(function () {
+        return true;
+      })
+      .catch(function () {
+        return false;
+      });
+    if (!hasCacheFile) {
+      return { type: 'selfhosted', detail: true };
     }
 
     return { type: 'valid', detail: true };
@@ -317,14 +253,26 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
 
   // Typically a package is organized by release (ex: go has 1.20, 1.21, etc),
   // but we will organize by the build (ex: go1.20-darwin-arm64.tar.gz, etc).
-  bc.getPackages = async function ({ Releases, name, date }) {
-    if (!date) {
-      date = new Date();
+  bc.getPackages = async function (args) {
+    let name = args.name;
+    let warm = bc._caches[name];
+    if (warm) {
+      return _doGetPackages(args);
     }
-    let isoDate = date.toISOString();
-    let yearMonth = isoDate.slice(0, 7);
-    let dataFile = `${cacheDir}/${yearMonth}/${name}.json`;
-    let tsFile = `${cacheDir}/${yearMonth}/${name}.updated.txt`;
+    let inflight = bc._inflight[name];
+    if (inflight) {
+      return inflight;
+    }
+    let p = _doGetPackages(args).finally(function () {
+      delete bc._inflight[name];
+    });
+    bc._inflight[name] = p;
+    return p;
+  };
+
+  async function _doGetPackages({ name }) {
+    let dataFile = `${LEGACY_CACHE_DIR}/${name}.json`;
+    let tsFile = `${LEGACY_CACHE_DIR}/${name}.updated.txt`;
 
     let tsDate;
     {
@@ -378,7 +326,7 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
       }
     }
     if (!projInfo) {
-      projInfo = await getLatestBuilds(Releases, installersDir, cacheDir, name);
+      return meta;
     }
     let latestProjInfo = await BuildsCacher.transformAndUpdate(
       name,
@@ -389,63 +337,8 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     );
     bc._caches[name] = latestProjInfo;
 
-    process.nextTick(async function () {
-      let now = date.valueOf();
-      let age = now - projInfo.updated;
-
-      let fresh = age < bc._staleAge;
-      if (fresh) {
-        return;
-      }
-
-      projInfo = await getLatestBuilds(Releases, installersDir, cacheDir, name);
-      let latestProjInfo = BuildsCacher.transformAndUpdate(
-        name,
-        projInfo,
-        meta,
-        date,
-        bc,
-      );
-      bc._caches[name] = latestProjInfo;
-    });
-
-    return projInfo;
-  };
-
-  // Makes sure that packages are updated once an hour, on average
-  bc._staleNames = [];
-  bc._freshenTimeout = null;
-  bc.freshenRandomPackage = async function (minDelay) {
-    if (!minDelay) {
-      minDelay = 15 * 1000;
-    }
-
-    if (bc._staleNames.length === 0) {
-      let dirs = await bc.getProjectsByType();
-      bc._staleNames = Object.keys(dirs.valid);
-      bc._staleNames.sort(function () {
-        return 0.5 - Math.random();
-      });
-    }
-
-    let name = bc._staleNames.pop();
-    void (await bc.getPackages({
-      //Releases: Releases,
-      name: name,
-      date: new Date(),
-    }));
-    console.info(`[INFO] freshenRandomPackage: ${name}`);
-
-    let hour = 60 * 60 * 1000;
-    let delay = minDelay;
-    let spread = hour / bc._staleNames.length;
-    let seed = Math.random();
-    delay += seed * spread;
-
-    clearTimeout(bc._freshenTimeout);
-    bc._freshenTimeout = setTimeout(bc.freshenRandomPackage, delay);
-    bc._freshenTimeout.unref();
-  };
+    return latestProjInfo;
+  }
 
   /**
    * Given a list of acceptable formats, get the sorted list of of formats.
@@ -537,7 +430,10 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
       exts.push('.gz');
       exts.push('.sh');
     }
-    exts.push('.git');
+    let hasGit = formats.includes('git') || formats.includes('.git');
+    if (hasGit) {
+      exts.push('.git');
+    }
 
     // Fallbacks
     // (we include everything to bubble an extract error over not found)
@@ -646,29 +542,19 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
       return null;
     }
 
-    for (let _triplet of triplets) {
-      let targetReleases = projInfo.releasesByTriplet[_triplet];
-      if (!targetReleases) {
-        continue;
-      }
+    // Version-first iteration, not triplet-first: take the newest
+    // version even when its only build lives in a fallback triplet
+    // (e.g. serviceman v1.0.1 only exists at posix_2017-ANYARCH-none).
+    for (let lexver of projInfo.lexvers) {
+      let ver = projInfo.lexversMap[lexver] || lexver;
 
-      let versions = Object.keys(targetReleases);
-      //console.log('dbg: targetRelease versions', versions);
-      let lexvers = [];
-      for (let version of versions) {
-        let lexPrefix = Lexver.parseVersion(version);
-        lexvers.push(lexPrefix);
-      }
-      lexvers.sort();
-      lexvers.reverse();
-      // TODO get the other matchInfo props
+      for (let _triplet of triplets) {
+        let targetReleases = projInfo.releasesByTriplet[_triplet];
+        if (!targetReleases) {
+          continue;
+        }
 
-      // Make sure that these releases are the expected version
-      // (ex: jq1.7 => darwin-arm64-libc, jq1.6 => darwin-x86_64-libc)
-      for (let matchver of lexvers) {
-        let ver = projInfo.lexversMap[matchver] || matchver;
         let packages = targetReleases[ver];
-        //console.log('dbg: packages', packages);
         if (!packages) {
           continue;
         }
@@ -719,22 +605,32 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
       return triplets;
     }
 
+    // Prefer platform-specific matches over ANYOS/ANYARCH fallbacks.
+    // This ensures e.g. darwin-aarch64-none matches before
+    // ANYOS-ANYARCH-none (.git source URLs from old releases).
     let oses = [];
     if (hostTarget.os === 'windows') {
-      oses = ['ANYOS', 'windows'];
+      oses = ['windows', 'ANYOS'];
     } else if (hostTarget.os === 'android') {
-      oses = ['ANYOS', 'posix_2017', 'posix_2024', 'android', 'linux'];
+      oses = ['android', 'linux', 'posix_2017', 'posix_2024', 'ANYOS'];
     } else {
-      oses = ['ANYOS', 'posix_2017', 'posix_2024', hostTarget.os];
+      oses = [hostTarget.os, 'posix_2017', 'posix_2024', 'ANYOS'];
     }
 
     let waterfall = HostTargets.WATERFALL[hostTarget.os] || {};
     let arches = waterfall[hostTarget.arch] ||
       HostTargets.WATERFALL.ANYOS[hostTarget.arch] || [hostTarget.arch];
-    arches = ['ANYARCH'].concat(arches);
+    arches = arches.concat(['ANYARCH']);
     let libcs = waterfall[hostTarget.libc] ||
       HostTargets.WATERFALL.ANYOS[hostTarget.libc] || [hostTarget.libc];
 
+    // Extend the glibc-host waterfall: the table only lists [none, libc]
+    // but Rust projects (bat, rg) and node ship libc='gnu' builds, and
+    // static musl builds also run on glibc hosts.
+    if (hostTarget.libc === 'libc' && !libcs.includes('gnu')) {
+      libcs = ['none', 'gnu', 'musl', 'libc'];
+    }
+
     for (let os of oses) {
       for (let arch of arches) {
         for (let libc of libcs) {
@@ -762,10 +658,17 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
 };
 
 BuildsCacher._classify = function (bc, projInfo, build) {
-  /* jshint maxcomplexity: 25 */
-  let maybeInstallable = Triplet.maybeInstallable(projInfo, build);
-  if (!maybeInstallable) {
-    return null;
+  /* jshint maxcomplexity: 30 */
+  // Cache entries arrive pre-classified (os/arch/libc/ext set). Skip
+  // maybeInstallable for those — it false-rejects names ending in a
+  // version tag (`serviceman-v1.0.1`, `v1.0.1.zip`).
+  let cacheClassified =
+    build.os && build.arch && build.libc && build.ext;
+  if (!cacheClassified) {
+    let maybeInstallable = Triplet.maybeInstallable(projInfo, build);
+    if (!maybeInstallable) {
+      return null;
+    }
   }
 
   if (LEGACY_OS_MAP[build.os]) {
@@ -829,16 +732,26 @@ BuildsCacher._classify = function (bc, projInfo, build) {
     bc.unknownTerms[term] = true;
   }
 
-  // {NAME}.windows.x86_64v2.musl.exe
-  //     windows-x86_64_v2-musl
+  // Skip termsToTarget for cache-classified entries: it false-flags
+  // e.g. .git URLs as os=ANYOS while the cache says os=posix_2017,
+  // and the mismatch check throws.
   target = { triplet: '' };
-  try {
-    void Triplet.termsToTarget(target, projInfo, build, terms);
-  } catch (e) {
-    console.error(`PACKAGE FORMAT CHANGE for '${projInfo.name}':`);
-    console.error(e.message);
-    console.error(build);
-    return null;
+  if (cacheClassified) {
+    target.os = build.os;
+    target.arch = build.arch;
+    target.libc = build.libc;
+    target.vendor = build.vendor || 'unknown';
+    target.android = false;
+    target.unknownTerms = [];
+  } else {
+    try {
+      void Triplet.termsToTarget(target, projInfo, build, terms);
+    } catch (e) {
+      console.error(`PACKAGE FORMAT CHANGE for '${projInfo.name}':`);
+      console.error(e.message);
+      console.error(build);
+      return null;
+    }
   }
 
   target.triplet = `${target.arch}-${target.vendor}-${target.os}-${target.libc}`;

_webi/builds.js

@@ -15,11 +15,8 @@ let bc = BuildsCacher.create({
   caches: CACHE_DIR,
   installers: INSTALLERS_DIR,
 });
-bc.freshenRandomPackage(600 * 1000);
 
 Builds.init = async function () {
-  bc.freshenRandomPackage(600 * 1000);
-
   let dirs = await bc.getProjectsByType();
   let projNames = Object.keys(dirs.valid);
 
@@ -27,7 +24,6 @@ Builds.init = async function () {
   await Parallel.run(parallel, projNames, getAll);
   async function getAll(name) {
     void (await bc.getPackages({
-      //Releases: Releases,
       name: name,
       date: new Date(),
     }));

_webi/classify-one.js

@@ -1,11 +1,14 @@
 'use strict';
 
+let Fs = require('node:fs/promises');
+let Os = require('node:os');
 let Path = require('node:path');
 
-// let Builds = require('./builds.js');
 let BuildsCacher = require('./builds-cacher.js');
 let Triplet = require('./build-classifier/triplet.js');
 
+let LEGACY_CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
+
 async function main() {
   let projName = process.argv[2];
   if (!projName) {
@@ -36,16 +39,11 @@ async function main() {
     arches: [],
     libcs: [],
     formats: [],
-    // TODO channels: [],
   };
 
-  let installersDir = Path.join(__dirname, '..');
-  let Releases = require(`${installersDir}/${projName}/releases.js`);
-  if (!Releases.latest) {
-    Releases.latest = Releases;
-  }
-
-  let projInfo = await Releases.latest();
+  let dataFile = Path.join(LEGACY_CACHE_DIR, `${projName}.json`);
+  let json = await Fs.readFile(dataFile, 'utf8');
+  let projInfo = JSON.parse(json);
 
   // let packages = await Builds.getPackage({ name: projName });
   // console.log(packages);
@@ -70,9 +68,11 @@ async function main() {
   console.log(`[DEBUG] transformed`);
   let sample = transformed.packages.slice(0, 20);
   console.log('packages:', sample, ':packages');
+  let firstTriplet = Object.keys(transformed.releasesByTriplet)[0];
+  let firstVersion = transformed.versions[0];
   console.log(
-    'releasesByTriplet:',
-    transformed.releasesByTriplet['linux-x86_64-none'][transformed.versions[0]],
+    `releasesByTriplet[${firstTriplet}][${firstVersion}]:`,
+    transformed.releasesByTriplet[firstTriplet]?.[firstVersion],
     ':releasesByTriplet',
   );
   console.log('versions:', transformed.versions, ':versions');

_webi/lint-builds.js

@@ -139,8 +139,6 @@ async function main() {
     console.info('');
   }
 
-  bc.freshenRandomPackage(600 * 1000);
-
   let rows = [];
   let triples = [];
   let valids = Object.keys(dirs.valid);

_webi/normalize.js

@@ -1,259 +0,0 @@
-'use strict';
-
-// this may need customizations between packages
-var osMap = {
-  macos: /(\b|_)(apple|os(\s_-)?x\b|mac|darwin|iPhone|iOS|iPad)/i,
-  linux: /(\b|_)(linux)/i,
-  freebsd: /(\b|_)(freebsd)/i,
-  windows: /(\b|_)(win|microsoft|msft)/i,
-  sunos: /(\b|_)(sun)/i,
-  aix: /(\b|_)(aix)/i,
-};
-
-var maps = {
-  oses: {},
-  arches: {},
-  libcs: {},
-  formats: {},
-};
-
-Object.keys(osMap).forEach(function (name) {
-  maps.oses[name] = true;
-});
-
-var formats = ['zip', 'xz', 'tar', 'pkg', 'msi', 'git', 'exe', 'dmg', 'git'];
-formats.forEach(function (name) {
-  maps.formats[name] = true;
-});
-
-// evaluation order matters
-// (i.e. otherwise x86 and x64 can cross match)
-var arches = [
-  // arm64/aarch64 has very high specificity, so it comes first
-  'arm64',
-  // arm 7 is also generic aarch/arm/arm32
-  'armv7l',
-  // arm6 can run on armv7
-  'armv6l',
-  // amd64 is more likely and less often specified than arm64
-  'amd64',
-  'x86',
-  'ppc64le',
-  'ppc64',
-  's390x',
-];
-// Used for detecting system arch from package download url, for example:
-//
-// https://git.com/org/foo/releases/v0.7.9/foo-aarch64-linux-musl.tar.gz
-// https://git.com/org/foo/releases/v0.7.9/foo-arm-linux-musleabihf.tar.gz
-// https://git.com/org/foo/releases/v0.7.9/foo-armv7-linux-musleabihf.tar.gz
-// https://git.com/org/foo/releases/v0.7.9/foo-x86_64-linux-musl.tar.gz
-//
-var archMap = {
-  arm64: /(\b|_)(aarch64|arm64)/i,
-  armv7l: /(\b|_)(arm32|arm[_\-]?v?7l?)/i,
-  armv6l: /(\b|_)(arm|aarch32|arm[_\-]?v?6l?)(\b|_)/i,
-  //amd64: /(amd.?64|x64|[_\-]64)/i,
-  amd64:
-    /(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)64([_\-]?bit)?(\b|_)/i,
-  //x86: /(86)(\b|_)/i,
-  x86: /(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)(86|32|i?386)([_\-]?bit)?(\b|_)/i,
-  ppc64le: /(\b|_)(ppc64le)/i,
-  ppc64: /(\b|_)(ppc64)(\b|_)/i,
-  s390x: /(\b|_)(s390x)/i,
-};
-arches.forEach(function (name) {
-  maps.arches[name] = true;
-});
-
-var libcs = ['none', 'musl', 'gnu', 'msvc', 'libc'];
-libcs.forEach(function (name) {
-  maps.libcs[name] = true;
-});
-
-function normalize(all) {
-  /* jshint maxcomplexity:50 */
-  /* jshint maxdepth:10 */
-  var supported = {
-    oses: {},
-    arches: {},
-    libcs: {},
-    formats: {},
-  };
-
-  for (let rel of all.releases) {
-    rel.version = rel.version.replace(/^v/i, '');
-
-    if (!rel.name) {
-      rel.name = rel.download.replace(/.*\//, '');
-    }
-
-    if (!rel.os) {
-      rel.os = 'unknown';
-
-      let osNames = Object.keys(osMap);
-      for (let osName of osNames) {
-        let relName = rel.name || rel.download;
-        let osRegExp = osMap[osName];
-        let matches = osRegExp.test(relName);
-        if (matches) {
-          rel.os = osName;
-          break;
-        }
-      }
-    }
-    supported.oses[rel.os] = true;
-
-    if (!rel.arch) {
-      for (let arch of arches) {
-        let name = rel.name || rel.download;
-        let isArch = name.match(archMap[arch]);
-        if (isArch) {
-          rel.arch = arch;
-          break;
-        }
-      }
-    }
-    if (!rel.arch) {
-      if ('macos' === rel.os) {
-        rel.arch = 'amd64';
-      }
-    }
-    supported.arches[rel.arch] = true;
-
-    // note: depends on rel.os
-    if (!rel.libc) {
-      let isMusl;
-      let isMsvc;
-      let isStatic;
-      let isGnu;
-
-      // extra blocks to prevent copy pasta errors
-
-      {
-        let muslRe = /(\b|_)(musl)(\b|_)/i;
-        isMusl = muslRe.test(rel.download) || muslRe.test(rel.name);
-      }
-
-      {
-        let msvcRe = /(\b|_)(msvc)(\b|_)/i;
-        isMsvc = msvcRe.test(rel.download) || msvcRe.test(rel.name);
-      }
-
-      {
-        let staticRe = /(\b|_)(static)(\b|_)/i;
-        isStatic = staticRe.test(rel.download) || staticRe.test(rel.name);
-      }
-
-      {
-        let gnuRe = /(\b|_)(gnu|glibc|libc)(\b|_)/i;
-        isGnu = gnuRe.test(rel.download) || gnuRe.test(rel.name);
-      }
-
-      if (isMusl) {
-        // we specifically tag things that need musl++ in their own releases
-        rel.libc = 'none';
-      } else if (isStatic) {
-        rel.libc = 'none';
-      } else if (isGnu) {
-        rel.libc = 'gnu';
-        if (rel.os === 'windows') {
-          // windows gnu is static
-          rel.libc = 'none';
-        } else if (rel.os === 'darwin') {
-          // if glibc is required on macos, it'll be static
-          rel.libc = 'none';
-        }
-      } else if (isMsvc) {
-        rel.libc = 'msvc';
-      } else {
-        // The default is no requirement for any particular libc
-        // (Go, Zig, POSIX Shell, JS, etc)
-        // and hopefully we never have to worry about mingw and friends
-        rel.libc = 'none';
-      }
-    }
-    supported.libcs[rel.libc] = true;
-
-    var tarExt;
-    if (!rel.ext) {
-      // pkg-v1.0.tar.gz => ['gz', 'tar', '0', 'pkg-v1']
-      // pkg-v1.0.tar => ['tar', '0' ,'pkg-v1']
-      // pkg-v1.0.zip => ['zip', '0', 'pkg-v1']
-      var exts = (rel.name || rel.download).split('.');
-      if (1 === exts.length) {
-        // for bare releases in the format of foo-linux-amd64
-        rel.ext = 'exe';
-      }
-      exts = exts.reverse().slice(0, 2);
-      if ('tar' === exts[1]) {
-        rel.ext = exts.reverse().join('.');
-        tarExt = 'tar';
-      } else if ('tgz' === exts[0]) {
-        rel.ext = 'tar.gz';
-        tarExt = 'tar';
-      } else {
-        rel.ext = exts[0];
-      }
-      if (/\-|linux|mac|os[_\-]?x|arm|amd|86|64|mip/i.test(rel.ext)) {
-        // for bare releases in the format of foo.linux-amd64
-        rel.ext = 'exe';
-      }
-    }
-    supported.formats[tarExt || rel.ext] = true;
-
-    if (!rel.channel) {
-      // basically like this: (+.-_)(beta|rc)(0-9)(+.-_)
-      // matches:
-      //   - v1.0-beta
-      //   - v1.0-beta1.1
-      //   - v1.0-beta-11
-      // won't match:
-      //   - v1.0beta
-      //   - v1.0-beta1b
-      let isBetaRe =
-        /(\b|_)(alpha|beta|dev|developer|prev|preview|rc)(\d+)(\b|_)/;
-      let isBeta = isBetaRe.test(rel.name);
-      if (isBeta) {
-        rel.channel = 'beta';
-      } else {
-        rel.channel = 'stable';
-      }
-    }
-
-    if (all.download) {
-      rel.download = all.download.replace(/{{ download }}/, rel.download);
-    }
-  }
-
-  all.oses = Object.keys(supported.oses).filter(function (name) {
-    return maps.oses[name];
-  });
-  all.arches = Object.keys(supported.arches).filter(function (name) {
-    return maps.arches[name];
-  });
-  all.libcs = Object.keys(supported.libcs).filter(function (name) {
-    return maps.libcs[name];
-  });
-  all.formats = Object.keys(supported.formats).filter(function (name) {
-    return maps.formats[name];
-  });
-
-  return all;
-}
-
-module.exports = normalize;
-module.exports._debug = function (all) {
-  all = normalize(all);
-  all.releases = all.releases
-    .filter(function (r) {
-      return ['windows', 'macos', 'linux'].includes(r.os) && 'amd64' === r.arch;
-    })
-    .slice(0, 10);
-  return all;
-};
-// NOT in order of priority (which would be tar, xz, zip, ...)
-module.exports.formats = formats;
-module.exports.arches = arches;
-module.exports.libcs = libcs;
-module.exports.formatsMap = maps.formats;

_webi/test.js

@@ -49,7 +49,7 @@ var baseurl = 'https://webinstall.dev';
 var maxLen = 0;
 console.info('');
 console.info('Has the necessary files?');
-['README.md', 'releases.js', 'install.sh', 'install.ps1']
+['README.md', 'install.sh', 'install.ps1']
   .map(function (node) {
     maxLen = Math.max(maxLen, node.length);
     return node;

_webi/transform-releases.js

@@ -2,75 +2,30 @@
 
 var Releases = module.exports;
 
+var Fs = require('node:fs/promises');
+var Os = require('node:os');
 var path = require('path');
-var _normalize = require('./normalize.js');
-
 var cache = {};
-//var staleAge = 5 * 1000;
-//var expiredAge = 15 * 1000;
-var staleAge = 5 * 60 * 1000;
-var expiredAge = 15 * 60 * 1000;
 
-let installerDir = path.join(__dirname, '..');
+var LEGACY_CACHE_DIR = path.join(Os.homedir(), '.cache/webi/legacy');
 
-Releases.get = async function (pkgdir) {
-  let get;
-  try {
-    get = require(`${pkgdir}/releases.js`);
-    // TODO update all releases files with module.exports.xxxx = 'foo';
-    if (!get.latest) {
-      get.latest = get;
-    }
-  } catch (e) {
-    let err = new Error('no releases.js for', pkgdir.split(/[\/\\]+/).pop());
-    err.code = 'E_NO_RELEASE';
-    throw err;
-  }
-
-  let all = await get.latest();
-
-  return _normalize(all);
-};
-
-// TODO needs a proper test, and more accurate (though perhaps far less simple) code
+// Sort releases by ext preference and libc within the same version.
+// The cache is already sorted by version (stable before beta, newest first),
+// so we only re-order within the same version string.
 function createFormatsSorter(formats) {
-  return function sortByVerExt(a, b) {
-    function lexver(semver) {
-      // v1.20.156 => 00001.00020.00156.zzzzz
-      // TODO BUG: v1.20.156-rc2 => 00001.00020.00156.rc2zz
-      var parts = semver.split(/[+\.\-]/g);
-      while (parts.length < 4) {
-        parts.push('');
-      }
-      return parts
-        .map(function (num, i) {
-          if (3 === i) {
-            return num.toString().padEnd(10, 'z');
-          }
-          return num.toString().padStart(10, '0');
-        })
-        .join('.');
-    }
-
-    var aver = lexver(a.version);
-    var bver = lexver(b.version);
-    if (aver > bver) {
-      //console.log(aver, '>', bver);
-      return -1;
-    }
-    if (aver < bver) {
-      //console.log(aver, '<', bver);
-      return 1;
+  return function sortByExtLibc(a, b) {
+    if (a.version !== b.version) {
+      // Array.sort is stable (V8, ES2019), so returning 0 across
+      // versions preserves the cache's pre-sorted version-desc order.
+      return 0;
     }
 
     var aExtPri = formats.indexOf(a.ext.replace(/tar\..*/, 'tar'));
     var bExtPri = formats.indexOf(b.ext.replace(/tar\..*/, 'tar'));
     if (aExtPri > bExtPri) {
-      //console.log(a.ext, aExtPri, '>', b.ext, bExtPri);
       return -1;
     }
     if (aExtPri < bExtPri) {
-      //console.log(a.ext, aExtPri, '<', b.ext, bExtPri);
       return 1;
     }
 
@@ -87,99 +42,39 @@ function createFormatsSorter(formats) {
 }
 
 async function getCachedReleases(pkg) {
-  // returns { download: '<template string>', releases: [{ version, date, os, arch, lts, channel, download}] }
+  // returns { download: '', releases: [{ version, date, os, arch, lts, channel, download}] }
 
-  async function chainCachePromise(fn) {
-    cache[pkg].promise = cache[pkg].promise.then(fn);
-    return cache[pkg].promise;
+  if (cache[pkg]) {
+    return cache[pkg];
   }
 
-  async function sleep(ms) {
-    return await new Promise(function (resolve, reject) {
-      setTimeout(resolve, ms);
-    });
-  }
+  let dataFile = `${LEGACY_CACHE_DIR}/${pkg}.json`;
 
-  async function putCache() {
-    var age = Date.now() - cache[pkg].updatedAt;
-    if (age < staleAge) {
-      //console.debug('NOT STALE ANYMORE - updated in previous promise');
-      return cache[pkg].all;
+  let json = await Fs.readFile(dataFile, 'utf8').catch(function (err) {
+    if (err.code === 'ENOENT') {
+      return null;
     }
+    throw err;
+  });
 
-    //console.debug('DOWNLOADING NEW "%s" releases', pkg);
-    var pkgdir = path.join(installerDir, pkg);
-
-    // workaround for request timeout seeming to not work
-    let complete = false;
-    await Promise.race([
-      Releases.get(pkgdir)
-        .catch(function (err) {
-          if ('E_NO_RELEASE' === err.code) {
-            let all = { _error: 'E_NO_RELEASE', download: '', releases: [] };
-            return all;
-          }
-
-          throw err;
-        })
-        .catch(function (err) {
-          let hasReleases = cache[pkg].all?.releases?.length > 1;
-          if (!hasReleases) {
-            throw err;
-          }
-
-          console.error(`Error: the BOOGEYMAN got us!`);
-          console.error(err.stack);
-
-          return cache[pkg].all;
-        })
-        .then(function (all) {
-          // Note: it is possible for slightly older data
-          // to replace slightly newer data, but this is better
-          // than being in a cycle where release updates _always_
-          // take longer than expected.
-          //console.debug('DOWNLOADED NEW "%s" releases', pkg);
-          cache[pkg].updatedAt = Date.now();
-          cache[pkg].all = all;
-          complete = true;
-        }),
-      sleep(15000).then(function () {
-        if (complete) {
-          return;
-        }
-        console.error(`request timeout waiting for '${pkg}' release info`);
-      }),
-    ]);
-
-    return cache[pkg].all;
+  if (!json) {
+    let empty = { download: '', releases: [] };
+    cache[pkg] = empty;
+    return empty;
   }
 
-  if (!cache[pkg]) {
-    cache[pkg] = {
-      updatedAt: 0,
-      all: { download: '', releases: [] },
-      promise: Promise.resolve(),
-    };
+  let all;
+  try {
+    all = JSON.parse(json);
+  } catch (e) {
+    console.error(`error: ${dataFile}:\n\t${e.message}`);
+    let empty = { download: '', releases: [] };
+    cache[pkg] = empty;
+    return empty;
   }
 
-  var bgRenewal;
-  var age = Date.now() - cache[pkg].updatedAt;
-  var fresh = age < staleAge;
-  if (!fresh) {
-    bgRenewal = chainCachePromise(putCache);
-  }
-
-  var tooStale = age > expiredAge;
-  if (!tooStale) {
-    return await cache[pkg].all;
-  }
-
-  return await Promise.race([
-    bgRenewal,
-    sleep(5000).then(function () {
-      return cache[pkg].all;
-    }),
-  ]);
+  cache[pkg] = all;
+  return all;
 }
 
 async function filterReleases(
@@ -190,15 +85,22 @@ async function filterReleases(
   // sort the most compatible format first
   // (i.e. so that we don't do .pkg on linux except on purpose)
   var rformats = formats.slice(0).reverse();
-  var sortByVerExt = createFormatsSorter(rformats);
+  var sortByExtLibc = createFormatsSorter(rformats);
   var reVer = new RegExp('^' + ver + '\\b');
 
   function selectMatches(rel) {
+    /* jshint maxcomplexity: 25 */
     if (os) {
-      if (rel.os !== '*') {
-        if (rel.os !== os) {
-          return false;
-        }
+      // '*' = any OS (matches anything, including windows).
+      // 'posix' / 'posix_20xx' = any POSIX OS (matches linux, macos,
+      // freebsd, etc., but NOT windows).
+      let isPosix = rel.os === 'posix' || rel.os.startsWith('posix_20');
+      let osMatches =
+        rel.os === '*' ||
+        rel.os === os ||
+        (isPosix && os !== 'windows');
+      if (!osMatches) {
+        return false;
       }
     }
 
@@ -210,7 +112,10 @@ async function filterReleases(
       }
     }
 
-    if (rel.libc !== 'none') {
+    // libc='libc' is serve-releases.js's default when the caller
+    // didn't pin one — treat it as 'no preference', not a filter.
+    let isMeaningfulLibc = libc && libc !== 'libc' && rel.libc !== 'none';
+    if (isMeaningfulLibc) {
       let releaseRequiresMusl = rel.libc === 'musl';
       // goal: handle non-glibc (Alpine / Docker / musl)
       let osHasMusl = libc === 'musl';
@@ -257,7 +162,7 @@ async function filterReleases(
     return true;
   }
 
-  var sortedRels = all.releases.filter(selectMatches).sort(sortByVerExt);
+  var sortedRels = all.releases.filter(selectMatches).sort(sortByExtLibc);
   //console.log(sortedRels.slice(0, 4));
 
   return sortedRels.slice(0, limit || 1000);
@@ -416,8 +321,8 @@ Releases.getReleases = function ({
 };
 
 if (require.main === module) {
-  return module
-    .exports({
+  return Releases
+    .getReleases({
       pkg: 'node',
       ver: '',
       os: 'macos',

aliasman/releases.js

@@ -1,22 +0,0 @@
-'use strict';
-
-let Releases = module.exports;
-
-let GitHubSource = require('../_common/github-source.js');
-let owner = 'BeyondCodeBootcamp';
-let repo = 'aliasman';
-
-Releases.latest = async function () {
-  let all = await GitHubSource.getDistributables({ owner, repo });
-  for (let pkg of all.releases) {
-    pkg.os = 'posix_2017';
-  }
-  return all;
-};
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

arc/releases.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'mholt';
-var repo = 'archiver';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all._names = ['archiver', 'arc'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

atomicparsley/releases.js

@@ -1,79 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'wez';
-var repo = 'atomicparsley';
-
-let targets = {
-  x86win: {
-    os: 'windows',
-    arch: 'x86',
-    libc: 'msvc',
-  },
-  x64win: {
-    os: 'windows',
-    arch: 'amd64',
-    // https://github.com/wez/atomicparsley/issues/6#issuecomment-1364523028
-    libc: 'msvc',
-  },
-  x64mac: {
-    os: 'macos',
-    arch: 'amd64',
-  },
-  x64lin: {
-    os: 'linux',
-    arch: 'amd64',
-    libc: 'gnu',
-  },
-  x64musl: {
-    os: 'linux',
-    arch: 'amd64',
-    libc: 'musl',
-  },
-};
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    for (let rel of all.releases) {
-      let windows32 = rel.name.includes('WindowsX86.');
-      if (windows32) {
-        Object.assign(rel, targets.x86win);
-        continue;
-      }
-
-      let windows64 = rel.name.includes('Windows.');
-      if (windows64) {
-        Object.assign(rel, targets.x64win);
-        continue;
-      }
-
-      let macos64 = rel.name.includes('MacOS');
-      if (macos64) {
-        Object.assign(rel, targets.x64mac);
-        continue;
-      }
-
-      let musl64 = rel.name.includes('Alpine');
-      if (musl64) {
-        Object.assign(rel, targets.x64musl);
-        continue;
-      }
-
-      let lin64 = rel.name.includes('Linux.');
-      if (lin64) {
-        Object.assign(rel, targets.x64lin);
-        continue;
-      }
-    }
-    all._names = ['AtomicParsley', 'atomicparsley'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-    //console.info(JSON.stringify(all, null, 2));
-  });
-}

awless/releases.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'wallix';
-var repo = 'awless';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // remove checksums and .deb
-    all.releases = all.releases.filter(function (rel) {
-      return !/(\.txt)|(\.deb)$/i.test(rel.name);
-    });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

bat/install.sh

@@ -28,6 +28,22 @@ __init_bat() {
         # chmod a+x ~/.local/opt/bat-v0.15.4/bin/bat
         chmod a+x "$pkg_src_cmd"
 
+        # install completions if present (autocomplete/)
+        if test -d ./bat-*/autocomplete; then
+            mkdir -p "$pkg_src_dir/share/bash-completion/completions"
+            mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
+            mkdir -p "$pkg_src_dir/share/zsh/site-functions"
+            mv ./bat-*/autocomplete/bat.bash "$pkg_src_dir/share/bash-completion/completions/bat" 2>/dev/null || true
+            mv ./bat-*/autocomplete/bat.fish "$pkg_src_dir/share/fish/vendor_completions.d/bat.fish" 2>/dev/null || true
+            mv ./bat-*/autocomplete/bat.zsh "$pkg_src_dir/share/zsh/site-functions/_bat" 2>/dev/null || true
+        fi
+
+        # install man page if present
+        if test -f ./bat-*/bat.1; then
+            mkdir -p "$pkg_src_dir/share/man/man1"
+            mv ./bat-*/bat.1 "$pkg_src_dir/share/man/man1/bat.1"
+        fi
+
         if ! [ -e ~/.config/bat/config ]; then
             mkdir -p ~/.config/bat/
             touch ~/.config/bat/config

bat/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'sharkdp';
-var repo = 'bat';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

bun/releases.js

@@ -1,61 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'oven-sh';
-var repo = 'bun';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // collect baseline asset names so we can prefer them over non-baseline
-    // (baseline builds avoid SIGILL on older/container CPUs)
-    let baselineNames = new Set();
-    all.releases.forEach(function (r) {
-      if (r.name.includes('-baseline')) {
-        baselineNames.add(r.name.replace('-baseline', ''));
-      }
-    });
-
-    all.releases = all.releases
-      .filter(function (r) {
-        if (r.name.includes('-profile')) {
-          return false;
-        }
-
-        if (r.name.endsWith('.txt') || r.name.endsWith('.asc')) {
-          return false;
-        }
-
-        // drop the non-baseline asset when a baseline twin exists
-        if (!r.name.includes('-baseline') && baselineNames.has(r.name)) {
-          return false;
-        }
-
-        let isMusl = r.name.includes('-musl');
-        if (isMusl) {
-          r._musl = true;
-          r.libc = 'musl';
-        } else if (r.name.includes('-linux-')) {
-          r.libc = 'gnu';
-        }
-
-        return true;
-      })
-      .map(function (r) {
-        // bun-linux-x64-baseline.zip => bun-linux-x64
-        r.name = r.name.replace('-baseline', '').replace(/\.zip$/, '');
-        // bun-v0.5.1 => v0.5.1
-        r.version = r.version.replace(/bun-/g, '');
-        return r;
-      });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

caddy/releases.js

@@ -1,27 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'caddyserver';
-var repo = 'caddy';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // remove checksums and .deb
-    all.releases = all.releases.filter(function (rel) {
-      let isOneOffAsset = rel.download.includes('buildable-artifact');
-      if (isOneOffAsset) {
-        return false;
-      }
-
-      return true;
-    });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

chromedriver/releases.js

@@ -1,101 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-// See <https://googlechromelabs.github.io/chrome-for-testing/>
-const releaseApiUrl =
-  'https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json';
-
-// {
-//   "timestamp": "2023-11-15T21:08:56.730Z",
-//   "versions": [
-//     {
-//       "version": "121.0.6120.0",
-//       "revision": "1222902",
-//       "downloads": {
-//         "chrome": [],
-//         "chromedriver": [
-//           {
-//             "platform": "linux64",
-//             "url": "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/121.0.6120.0/linux64/chromedriver-linux64.zip"
-//           },
-//           {
-//             "platform": "mac-arm64",
-//             "url": "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/121.0.6120.0/mac-arm64/chromedriver-mac-arm64.zip"
-//           },
-//           {
-//             "platform": "mac-x64",
-//             "url": "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/121.0.6120.0/mac-x64/chromedriver-mac-x64.zip"
-//           },
-//           {
-//             "platform": "win32",
-//             "url": "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/121.0.6120.0/win32/chromedriver-win32.zip"
-//           },
-//           {
-//             "platform": "win64",
-//             "url": "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/121.0.6120.0/win64/chromedriver-win64.zip"
-//           }
-//         ],
-//         "chrome-headless-shell": []
-//       }
-//     }
-//   ]
-// }
-
-module.exports = async function () {
-  let resp;
-  try {
-    resp = await Fetcher.fetch(releaseApiUrl, {
-      headers: { Accept: 'application/json' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'chromedriver' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let data = JSON.parse(resp.body);
-
-  let builds = [];
-  for (let release of data.versions) {
-    if (!release.downloads.chromedriver) {
-      continue;
-    }
-
-    let version = release.version;
-    for (let asset of release.downloads.chromedriver) {
-      let build = {
-        version: version,
-        download: asset.url,
-        // I' not sure that this is actually statically built but it
-        // seems to be and at worst we'll just get bug reports for Alpine
-        libc: 'none',
-      };
-
-      builds.push(build);
-    }
-  }
-
-  let all = {
-    download: '',
-    releases: builds,
-  };
-
-  return all;
-};
-
-if (module === require.main) {
-  module
-    .exports()
-    .then(function (all) {
-      all = require('../_webi/normalize.js')(all);
-      // just select the latest 20 for demonstration
-      all.releases = all.releases.slice(-20);
-      console.info(JSON.stringify(all, null, 2));
-    })
-    .catch(function (err) {
-      console.error('Error:', err);
-    });
-}

cilium/releases.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'cilium';
-var repo = 'cilium-cli';
-
-module.exports = async function () {
-  let all = await github(null, owner, repo);
-  return all;
-};
-
-if (module === require.main) {
-  (async function () {
-    let normalize = require('../_webi/normalize.js');
-    let all = await module.exports();
-    all = normalize(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  })();
-}

cmake/releases.js

@@ -1,53 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'Kitware';
-var repo = 'CMake';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    for (let rel of all.releases) {
-      if (rel.version.startsWith('v')) {
-        rel._version = rel.version.slice(1);
-      }
-
-      {
-        let linuxRe = /(\b|_)(linux|gnu)(\b|_)/i;
-        let isLinux = linuxRe.test(rel.download) || linuxRe.test(rel.name);
-
-        if (isLinux) {
-          let muslRe = /(\b|_)(musl|alpine)(\b|_)/i;
-          let isMusl = muslRe.test(rel.download) || muslRe.test(rel.name);
-          if (isMusl) {
-            rel.libc = 'musl';
-          } else {
-            rel.libc = 'gnu';
-          }
-          continue;
-        }
-      }
-
-      {
-        let windowsRe = /(\b|_)(win\d*|windows\d*)(\b|_)/i;
-        let isWindows =
-          windowsRe.test(rel.download) || windowsRe.test(rel.name);
-
-        if (isWindows) {
-          rel.libc = 'msvc';
-          continue;
-        }
-      }
-    }
-
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

comrak/releases.js

@@ -1,40 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'kivikakk';
-var repo = 'comrak';
-
-var ODDITIES = ['-musleabihf.1-'];
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    let builds = [];
-
-    loopBuilds: for (let build of all.releases) {
-      let isOddity;
-      for (let oddity of ODDITIES) {
-        isOddity = build.name.includes(oddity);
-        if (isOddity) {
-          break;
-        }
-      }
-      if (isOddity) {
-        continue;
-      }
-
-      builds.push(build);
-    }
-
-    all.releases = builds;
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

crabz/releases.js

@@ -1,31 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'sstadick';
-var repo = 'crabz';
-
-module.exports = async function () {
-  let all = await github(null, owner, repo);
-
-  let releases = [];
-  for (let rel of all.releases) {
-    let isSrc = rel.download.includes('-src.');
-    if (isSrc) {
-      continue;
-    }
-
-    releases.push(rel);
-  }
-  all.releases = releases;
-
-  return all;
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

curlie/releases.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'rs';
-var repo = 'curlie';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all._names = ['curlie', 'curl-httpie'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

dashcore/releases.js

@@ -1,31 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'dashpay';
-var repo = 'dash';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all.releases.forEach(function (rel) {
-      if (rel.name.includes('osx64')) {
-        rel.os = 'macos';
-      }
-
-      if (rel.version.startsWith('v')) {
-        rel._version = rel.version.slice(1);
-      }
-    });
-
-    all._names = ['dashd', 'dashcore'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

dashd/releases.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('../dashcore/releases.js');

dashmsg/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'dashhive';
-var repo = 'dashmsg';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

delta/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'dandavison';
-var repo = 'delta';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 15 for demonstration
-    all.releases = all.releases.slice(0, 15);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

deno/releases.js

@@ -1,42 +0,0 @@
-'use strict';
-
-var path = require('path');
-
-var github = require('../_common/github.js');
-var owner = 'denoland';
-var repo = 'deno';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // remove checksums and .deb
-    all.releases = all.releases
-      .filter(function (rel) {
-        let isMeta = rel.name.endsWith('.d.ts');
-        if (isMeta) {
-          return false;
-        }
-
-        return true;
-      })
-      .map(function (rel) {
-        var ext;
-        if (!rel.name.match(rel.version)) {
-          ext = path.extname(rel.name);
-          rel.filename =
-            rel.name.slice(0, rel.name.length - ext.length) +
-            '-' +
-            rel.version +
-            ext;
-        }
-        return rel;
-      });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

dotenv-linter/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'dotenv-linter';
-var repo = 'dotenv-linter';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

dotenv/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'therootcompany';
-var repo = 'dotenv';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

duckdns.sh/releases.js

@@ -1,22 +0,0 @@
-'use strict';
-
-let Releases = module.exports;
-
-let GitHubSource = require('../_common/github-source.js');
-let owner = 'BeyondCodeBootcamp';
-let repo = 'DuckDNS.sh';
-
-Releases.latest = async function () {
-  let all = await GitHubSource.getDistributables({ owner, repo });
-  for (let pkg of all.releases) {
-    pkg.os = 'posix_2017';
-  }
-  return all;
-};
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

fd/install.sh

@@ -27,6 +27,22 @@ __init_fd() {
 
         # chmod a+x "$HOME/.local/opt/fd-v8.1.1/bin/fd"
         chmod a+x "$pkg_src_cmd"
+
+        # install completions if present (autocomplete/{fd.bash,fd.fish,_fd})
+        if test -d ./fd-*/autocomplete; then
+            mkdir -p "$pkg_src_dir/share/bash-completion/completions"
+            mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
+            mkdir -p "$pkg_src_dir/share/zsh/site-functions"
+            mv ./fd-*/autocomplete/fd.bash "$pkg_src_dir/share/bash-completion/completions/fd" 2>/dev/null || true
+            mv ./fd-*/autocomplete/fd.fish "$pkg_src_dir/share/fish/vendor_completions.d/fd.fish" 2>/dev/null || true
+            mv ./fd-*/autocomplete/_fd "$pkg_src_dir/share/zsh/site-functions/_fd" 2>/dev/null || true
+        fi
+
+        # install man page if present
+        if test -f ./fd-*/fd.1; then
+            mkdir -p "$pkg_src_dir/share/man/man1"
+            mv ./fd-*/fd.1 "$pkg_src_dir/share/man/man1/fd.1"
+        fi
     }
 }
 

fd/releases.js

@@ -1,31 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'sharkdp';
-var repo = 'fd';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    let builds = [];
-
-    for (let build of all.releases) {
-      if (build.name === 'fd') {
-        continue;
-      }
-
-      builds.push(build);
-    }
-
-    all.releases = builds;
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

ffmpeg/releases.js

@@ -1,45 +0,0 @@
-'use strict';
-
-var path = require('path');
-
-var github = require('../_common/github.js');
-var owner = 'eugeneware';
-var repo = 'ffmpeg-static';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all.releases = all.releases
-      .filter(function (rel) {
-        let isFfmpeg = rel.name.includes('ffmpeg');
-        if (!isFfmpeg) {
-          return;
-        }
-
-        // remove README and LICENSE
-        return !['.README', '.LICENSE'].includes(path.extname(rel.name));
-      })
-      .map(function (rel) {
-        rel.version = rel.version.replace(/^b/, '');
-
-        if (/win32/.test(rel.name)) {
-          rel.os = 'windows';
-          rel.ext = 'exe';
-        }
-        if (/ia32/.test(rel.name)) {
-          rel.arch = '386';
-        } else if (/x64/.test(rel.name)) {
-          rel.arch = 'amd64';
-        }
-
-        return rel;
-      });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

ffuf/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'ffuf';
-var repo = 'ffuf';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

fish/releases.js

@@ -1,39 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'fish-shell';
-var repo = 'fish-shell';
-
-var ODDITIES = ['bundledpcre'];
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all.releases = all.releases
-      .map(function (rel) {
-        for (let oddity of ODDITIES) {
-          let isOddity = rel.name.includes(oddity);
-          if (isOddity) {
-            return;
-          }
-        }
-
-        // We can extract the macos bins from the .app
-        if (/\.app\.zip$/.test(rel.name)) {
-          rel.os = 'macos';
-          rel.arch = 'amd64';
-          return rel;
-        }
-      })
-      .filter(Boolean);
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

flutter/releases.js

@@ -1,132 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-let FLUTTER_OSES = ['macos', 'linux', 'windows'];
-
-/**
- * stable, beta, dev
- * @type {Object.<String, Boolean>}
- */
-let channelMap = {};
-
-// This can be spot-checked against
-// https://docs.flutter.dev/release/archive?tab=windows
-
-// The release URLs are
-// - https://storage.googleapis.com/flutter_infra_release/releases/releases_macos.json
-// - https://storage.googleapis.com/flutter_infra_release/releases/releases_linux.json
-// - https://storage.googleapis.com/flutter_infra_release/releases/releases_windows.json
-// The old release URLs are
-// - https://storage.googleapis.com/flutter_infra/releases/releases_macos.json
-// - https://storage.googleapis.com/flutter_infra/releases/releases_linux.json
-// - https://storage.googleapis.com/flutter_infra/releases/releases_windows.json
-
-// The data looks like
-// {
-//   "base_url": "https://storage.googleapis.com/flutter_infra/releases",
-//   "current_release": {
-//     "beta": "b22742018b3edf16c6cadd7b76d9db5e7f9064b5",
-//     "dev": "fa5883b78e566877613ad1ccb48dd92075cb5c23",
-//     "stable": "02c026b03cd31dd3f867e5faeb7e104cce174c5f"
-//   },
-//   "releases": [
-//     {
-//       "hash": "fa5883b78e566877613ad1ccb48dd92075cb5c23",
-//       "channel": "dev",
-//       "version": "2.3.0-16.0.pre",
-//       "release_date": "2021-05-27T23:58:47.683121Z",
-//       "archive": "dev/macos/flutter_macos_2.3.0-16.0.pre-dev.zip",
-//       "sha256": "f572b42d36714e6c58a3ed170b93bb414e2ced3ca4bde5094fbe18061cbcba6c"
-//     },
-//     {
-//       "hash": "02c026b03cd31dd3f867e5faeb7e104cce174c5f",
-//       "channel": "stable",
-//       "version": "2.2.1",
-//       "release_date": "2021-05-27T23:06:07.243882Z",
-//       "archive": "stable/macos/flutter_macos_2.2.1-stable.zip",
-//       "sha256": "6373d39ec563c337600baf42a42b258420208e4523d85479373e113d61d748df"
-//     },
-//     {
-//       "hash": "b22742018b3edf16c6cadd7b76d9db5e7f9064b5",
-//       "channel": "beta",
-//       "version": "2.2.0",
-//       "release_date": "2021-05-19T21:14:59.281482Z",
-//       "archive": "beta/macos/flutter_macos_2.2.0-beta.zip",
-//       "sha256": "31ab530e708f8d1274712211253a27a4ce7d676f139d30f2ec021df22382f052"
-//     }
-//   ]
-// }
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {Boolean} lts
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} [_filename]
- */
-
-module.exports = async function () {
-  let all = {
-    download: '',
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-    /** @type {Array<String>} */
-    channels: [],
-  };
-
-  for (let osname of FLUTTER_OSES) {
-    let resp;
-    try {
-      let url = `https://storage.googleapis.com/flutter_infra_release/releases/releases_${osname}.json`;
-      resp = await Fetcher.fetch(url, {
-        headers: { Accept: 'application/json' },
-      });
-    } catch (e) {
-      /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-      let err = e;
-      if (err.code === 'E_FETCH_RELEASES') {
-        err.message = `failed to fetch 'flutter' release data for ${osname}: ${err.response.status} ${err.response.body}`;
-      }
-      throw e;
-    }
-    let data = JSON.parse(resp.body);
-
-    let osBaseUrl = data.base_url;
-    let osReleases = data.releases;
-
-    for (let asset of osReleases) {
-      if (!channelMap[asset.channel]) {
-        channelMap[asset.channel] = true;
-      }
-
-      all.releases.push({
-        version: asset.version,
-        _version: `${asset.version}-${asset.channel}`,
-        lts: false,
-        channel: asset.channel,
-        date: asset.release_date.replace(/T.*/, ''),
-        download: `${osBaseUrl}/${asset.archive}`,
-        _filename: asset.archive,
-      });
-    }
-  }
-
-  all.channels = Object.keys(channelMap);
-
-  // note: versions have a waterfall relationship with channels:
-  // - a release that is in beta today may become stable tomorrow
-  // - semver prereleases are either beta or dev
-
-  return all;
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all.releases = all.releases.slice(25);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

fzf/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'junegunn';
-var repo = 'fzf';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

gh/install.sh

@@ -25,6 +25,12 @@ __init_gh() {
 
         # mv ./gh-*/gh ~/.local/opt/gh-v0.99.9/bin/gh
         mv ./"$pkg_cmd_name"*/bin/gh "$pkg_src_cmd"
+
+        # install man pages if present
+        if test -d ./"$pkg_cmd_name"*/share/man; then
+            mkdir -p "$pkg_src_dir/share"
+            mv ./"$pkg_cmd_name"*/share/man "$pkg_src_dir/share/man"
+        fi
     }
 
     # pkg_get_current_version is recommended, but (soon) not required

gh/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'cli';
-var repo = 'cli';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

git/releases.js

@@ -1,33 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'git-for-windows';
-var repo = 'git';
-
-module.exports = function () {
-  // TODO support mac and linux tarballs
-  return github(null, owner, repo).then(function (all) {
-    // See https://github.com/git-for-windows/git/wiki/MinGit
-    // also consider https://github.com/git-for-windows/git/wiki/Silent-or-Unattended-Installation
-    all.releases = all.releases
-      .filter(function (rel) {
-        rel.os = 'windows';
-        rel._version = rel.version.replace(/\.windows.1.*/, '');
-        rel._version = rel._version.replace(/\.windows(\.\d)/, '$1');
-        return (
-          /MinGit/i.test(rel.name || rel.download) &&
-          !/busybox/i.test(rel.name || rel.download)
-        );
-      })
-      .slice(0, 20);
-    all._names = ['MinGit', 'git'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

gitdeploy/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'therootcompany';
-var repo = 'gitdeploy';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

gitea/releases.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'go-gitea';
-var repo = 'gitea';
-
-var ODDITIES = ['-gogit-', '-docs-'];
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // remove checksums and .deb
-    all.releases = all.releases.filter(function (rel) {
-      for (let oddity of ODDITIES) {
-        let isOddity = rel.name.includes(oddity);
-        if (isOddity) {
-          return false;
-        }
-      }
-
-      return true;
-    });
-
-    // "windows-4.0" as a nod to Windows NT  ¯\_(ツ)_/¯
-    all._names = ['gitea', '-4.0-'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

go/releases.js

@@ -1,130 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-/** @type {Object.<String, String>} */
-let osMap = {
-  darwin: 'macos',
-};
-/** @type {Object.<String, String>} */
-let archMap = {
-  386: 'x86',
-};
-
-let ODDITIES = ['bootstrap', '-arm6.'];
-
-/**
- * @param {String} filename
- */
-function isOdd(filename) {
-  for (let oddity of ODDITIES) {
-    let isOddity = filename.includes(oddity);
-    if (isOddity) {
-      return true;
-    }
-  }
-}
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} arch
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} ext
- * @prop {String} [_filename]
- * @prop {String} hash
- * @prop {Boolean} lts
- * @prop {String} os
- */
-
-async function getDistributables() {
-  /*
-  {
-    version: 'go1.13.8',
-    stable: true,
-    files: [
-      {
-        filename: 'go1.13.8.src.tar.gz',
-        os: '',
-        arch: '',
-        version: 'go1.13.8',
-        sha256:
-          'b13bf04633d4d8cf53226ebeaace8d4d2fd07ae6fa676d0844a688339debec34',
-        size: 21631178,
-        kind: 'source'
-      }
-    ]
-  };
-  */
-
-  let resp;
-  try {
-    let url = 'https://golang.org/dl/?mode=json&include=all';
-    resp = await Fetcher.fetch(url, {
-      headers: { Accept: 'application/json' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'Go' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let goReleases = JSON.parse(resp.body);
-
-  let all = {
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-    download: '',
-  };
-
-  for (let release of goReleases) {
-    // Strip 'go' prefix, standardize version
-    let parts = release.version.slice(2).split('.');
-    while (parts.length < 3) {
-      parts.push('0');
-    }
-    let version = parts.join('.');
-    let fileversion = release.version.slice(2);
-
-    for (let asset of release.files) {
-      if (isOdd(asset.filename)) {
-        continue;
-      }
-
-      let filename = asset.filename;
-      let os = osMap[asset.os] || asset.os || '-';
-      let arch = archMap[asset.arch] || asset.arch || '-';
-      let build = {
-        version: version,
-        _version: fileversion,
-        lts: (parts[0] > 0 && release.stable) || false,
-        channel: (release.stable && 'stable') || 'beta',
-        date: '1970-01-01', // the world may never know
-        os: os,
-        arch: arch,
-        ext: '', // let normalize run the split/test/join
-        hash: '-', // not ready to standardize this yet
-        download: `https://dl.google.com/go/${filename}`,
-      };
-      all.releases.push(build);
-    }
-  }
-
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    //@ts-expect-error
-    all.releases = all.releases.slice(0, 10);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

golang/releases.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('../go/releases.js');

goreleaser/install.sh

@@ -25,6 +25,23 @@ __init_goreleaser() {
 
         # mv ./goreleaser-*/goreleaser ~/.local/opt/goreleaser-v1.21.2/bin/goreleaser
         mv ./goreleaser "$pkg_src_cmd"
+
+        # install completions if present (completions/{goreleaser.bash,.fish,.zsh})
+        if test -d ./completions; then
+            mkdir -p "$pkg_src_dir/share/bash-completion/completions"
+            mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
+            mkdir -p "$pkg_src_dir/share/zsh/site-functions"
+            mv ./completions/goreleaser.bash "$pkg_src_dir/share/bash-completion/completions/goreleaser" 2>/dev/null || true
+            mv ./completions/goreleaser.fish "$pkg_src_dir/share/fish/vendor_completions.d/goreleaser.fish" 2>/dev/null || true
+            mv ./completions/goreleaser.zsh "$pkg_src_dir/share/zsh/site-functions/_goreleaser" 2>/dev/null || true
+        fi
+
+        # install man page if present (manpages/goreleaser.1.gz)
+        if test -d ./manpages; then
+            mkdir -p "$pkg_src_dir/share/man/man1"
+            mv ./manpages/*.1.gz "$pkg_src_dir/share/man/man1/" 2>/dev/null || true
+            mv ./manpages/*.1 "$pkg_src_dir/share/man/man1/" 2>/dev/null || true
+        fi
     }
 
     # pkg_get_current_version is recommended, but (soon) not required

goreleaser/releases.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'goreleaser';
-var repo = 'goreleaser';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all._names = ['goreleaser', '1'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

gpg/releases.js

@@ -1,129 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-let ltsRe = /GnuPG-(2\.2\.[\d\.]+)/;
-
-function createRssMatcher() {
-  return new RegExp(
-    '<link>(https://sourceforge\\.net/projects/gpgosx/files/GnuPG-([\\d\\.]+)\\.dmg/download)</link>',
-    'g',
-  );
-}
-
-function createUrlMatcher() {
-  return new RegExp(
-    'https://sourceforge\\.net/projects/gpgosx/files/(GnuPG-([\\d\\.]+)\\.dmg)/download',
-    '',
-  );
-}
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} arch
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} ext
- * @prop {String} [_filename]
- * @prop {String} hash
- * @prop {Boolean} lts
- * @prop {String} os
- */
-
-async function getRawReleases() {
-  let resp;
-  try {
-    let url = 'https://sourceforge.net/projects/gpgosx/rss?path=/';
-    resp = await Fetcher.fetch(url, {
-      headers: { Accept: 'application/rss+xml' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'gpg' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let contentType = resp.headers.get('Content-Type');
-  if (!contentType?.includes('xml')) {
-    throw new Error(`Unexpected content type: ${contentType}`);
-  }
-
-  let matcher = createRssMatcher();
-  let links = [];
-  for (;;) {
-    let m = matcher.exec(resp.body);
-    if (!m) {
-      break;
-    }
-    links.push(m[1]);
-  }
-
-  return links;
-}
-
-/**
- * @param {Array<String>} links
- */
-function transformReleases(links) {
-  //console.log(JSON.stringify(links, null, 2));
-  //console.log(links.length);
-
-  let matcher = createUrlMatcher();
-
-  let builds = [];
-  for (let link of links) {
-    let isLts = ltsRe.test(link);
-    let parts = link.match(matcher);
-    if (!parts || !parts[2]) {
-      continue;
-    }
-
-    let segs = parts[2].split('.');
-    let version = segs.slice(0, 3).join('.');
-    if (segs.length > 3) {
-      version += '+' + segs.slice(3);
-    }
-    let fileversion = segs.join('.');
-
-    let build = {
-      name: parts[1],
-      version: version,
-      _version: fileversion,
-      lts: isLts,
-      channel: 'stable',
-      // TODO <pubDate>Sat, 19 Nov 2016 16:17:33 UT</pubDate>
-      date: '1970-01-01', // the world may never know
-      os: 'macos',
-      arch: 'amd64',
-      ext: 'dmg',
-      download: link,
-    };
-    builds.push(build);
-  }
-
-  return {
-    _names: ['GnuPG', 'gpgosx'],
-    releases: builds,
-  };
-}
-
-async function getDistributables() {
-  let releases = await getRawReleases();
-  let all = transformReleases(releases);
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10000);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

gprox/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'creedasaurus';
-var repo = 'gprox';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

grype/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'anchore';
-var repo = 'grype';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

hexyl/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'sharkdp';
-var repo = 'hexyl';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    //console.info(JSON.stringify(all));
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

hugo-extended/releases.js

@@ -1,32 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'gohugoio';
-var repo = 'hugo';
-
-module.exports = async function () {
-  let all = await github(null, owner, repo);
-
-  all.releases = all.releases.filter(function (rel) {
-    let isExtended = rel.name.includes('_extended_');
-    if (!isExtended) {
-      return false;
-    }
-
-    let isOldAlias = rel.name.includes('Linux-64bit');
-    if (isOldAlias) {
-      return false;
-    }
-
-    return true;
-  });
-
-  return all;
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

hugo/releases.js

@@ -1,32 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'gohugoio';
-var repo = 'hugo';
-
-module.exports = async function () {
-  let all = await github(null, owner, repo);
-
-  all.releases = all.releases.filter(function (rel) {
-    let isExtended = rel.name.includes('_extended_');
-    if (isExtended) {
-      return false;
-    }
-
-    let isOldAlias = rel.name.includes('Linux-64bit');
-    if (isOldAlias) {
-      return false;
-    }
-
-    return true;
-  });
-
-  return all;
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

iterm2/releases.js

@@ -1,93 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-async function getRawReleases() {
-  let resp;
-  try {
-    let url = 'https://iterm2.com/downloads.html';
-    resp = await Fetcher.fetch(url, {
-      headers: { Accept: 'text/html' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'iterm2' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-
-  let contentType = resp.headers.get('Content-Type');
-  if (!contentType || !contentType.includes('text/html')) {
-    throw new Error(`Unexpected Content-Type: ${contentType}`);
-  }
-
-  let lines = resp.body.split(/[<>]+/g);
-
-  /** @type {Array<String>} */
-  let links = [];
-  for (let str of lines) {
-    let m = str.match(/href="(https:\/\/iterm2\.com\/downloads\/.*\.zip)"/);
-    if (m && /iTerm2-[34]/.test(m[1])) {
-      if (m[1]) {
-        links.push(m[1]);
-      }
-    }
-  }
-
-  return links;
-}
-
-/**
- * @param {Array<String>} links
- */
-function transformReleases(links) {
-  let builds = [];
-  for (let link of links) {
-    let channel = /\/stable\//.test(link) ? 'stable' : 'beta';
-
-    let parts = link.replace(/.*\/iTerm2[-_]v?(\d_.*)\.zip/, '$1').split('_');
-    let version = parts.join('.').replace(/([_-])?beta/, '-beta');
-
-    // ex: 3.5.0-beta17 => 3_5_0beta17
-    // ex: 3.0.2-preview => 3_0_2-preview
-    let fileversion = version.replace(/\./g, '_');
-    fileversion = fileversion.replace(/-beta/g, 'beta');
-
-    let build = {
-      version: version,
-      _version: fileversion,
-      lts: 'stable' === channel,
-      channel: channel,
-      date: '1970-01-01', // the world may never know
-      os: 'macos',
-      arch: 'amd64',
-      ext: '', // let normalize run the split/test/join
-      download: link,
-    };
-    builds.push(build);
-  }
-
-  return {
-    _names: ['iTerm2', 'iterm2'],
-    releases: builds,
-  };
-}
-
-async function getDistributables() {
-  let rawReleases = await getRawReleases();
-  let all = transformReleases(rawReleases);
-
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10000);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

jq/releases.js

@@ -1,43 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'stedolan';
-var repo = 'jq';
-
-let ODDITIES = ['-no-oniguruma'];
-
-function isOdd(build) {
-  for (let oddity of ODDITIES) {
-    let isOddity = build.name.includes(oddity);
-    if (isOddity) {
-      return true;
-    }
-  }
-}
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    let builds = [];
-
-    for (let build of all.releases) {
-      let odd = isOdd(build);
-      if (odd) {
-        continue;
-      }
-
-      build.version = build.version.replace(/^jq\-/, '');
-      builds.push(build);
-    }
-
-    all.releases = builds;
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-    //console.info(JSON.stringify(all, null, 2));
-  });
-}

julia/releases.js

@@ -1,181 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-/** @type {Object.<String, String>} */
-let osMap = {
-  winnt: 'windows',
-  mac: 'darwin',
-};
-
-/** @type {Object.<String, String>} */
-let archMap = {
-  armv7l: 'armv7',
-  i686: 'x86',
-  powerpc64le: 'ppc64le',
-};
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} [arch]
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} [ext]
- * @prop {String} [_filename]
- * @prop {String} [hash]
- * @prop {String} [libc]
- * @prop {Boolean} [_musl]
- * @prop {Boolean} [lts]
- * @prop {String} [size]
- * @prop {String} os
- */
-
-async function getDistributables() {
-  let all = {
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-    download: '',
-    _names: ['julia', 'macaarch64'],
-  };
-
-  let resp;
-  try {
-    let url = 'https://julialang-s3.julialang.org/bin/versions.json';
-    resp = await Fetcher.fetch(url, {
-      headers: { Accept: 'application/json' },
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'julia' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-  let buildsByVersion = JSON.parse(resp.body);
-
-  /*
-      {
-        "url": "https://julialang-s3.julialang.org/bin/mac/aarch64/1.9/julia-1.9.4-macaarch64.tar.gz",
-        "triplet": "aarch64-apple-darwin14",
-        "kind": "archive",
-        "arch": "aarch64",
-        "asc": "-----BEGIN PGP SIGNATURE-----\n\niQIzBAABCAAdFiEENnPfUp2QSUd/drN1ZuPH3APW5JUFAmVTQBcACgkQZuPH3APW\n5JWUqw//QF/CJLAxXZdcXqpBulLUs/AX+x/8aERGcKxZqfeYOwA5efOzma8sASa/\nUzYCLp9E31x/RMDoZah6vPRRjBR+uVI6CLlXCCCmbAJP3lD2vlcY9LKe2/7s3Ba8\nhwITRaL6R5zNr+YfSHW1Hoj2tWgAQh9Y+Te7bP3jzwp5dlFygFO0pzoN+aeJbPNA\nbgT0ry8tgh78/tgNjgt4Ev3E2t3ehhrDGK4tgkkKieO6sdFz8jOacZVZkR1kLVEg\nMBIqmqZfk+5/HMf/6gHwd5GOXW8+GakN7vYXO+9VFETA2EiD5Z5k4Edq/VrNCn4O\npC6WHpBmVBBYX4aQtHkJyQaV8PtFd1j9338jUWlDaa6BVtX2hjRtU1k1oLZB1TTX\nl4awzYgFqdCRnFmOtzTdMDBcfedOiIHdTyxXPjJCX3i0GXmeuk89e5dE4P6sTT9n\n24GeBVQgMaXuNorg9L0oKrsQ8RDT20yEnVbfhy4Cvoq7dNIks6IxLZt10tjJFp1j\n0oJ5f6KucGyqFM9UhXRcuLj8Z+Q+JDzBs5c2pPe/bEzv6nChRNv252e5dve17esg\nK7tHkhXzM+6wl60oyRtpWghOubXyBDsNu1MH3qC9lWy3wmWuMN7no+yX0vGFyhMT\naxjLJSeYdccKD3SuzYotp3XwBKk05PFX9lWy0vuIjVj1sGWcES8=\n=G1tO\n-----END PGP SIGNATURE-----\n",
-        "sha256": "67542975e86102eec95bc4bb7c30c5d8c7ea9f9a0b388f0e10f546945363b01a",
-        "size": 119559478,
-        "version": "1.9.4",
-        "os": "mac",
-        "extension": "tar.gz"
-      }
-   */
-
-  let versions = Object.keys(buildsByVersion);
-  for (let version of versions) {
-    let release = buildsByVersion[version];
-
-    // let odd = isOdd(asset.filename);
-    // if (odd) {
-    //   return;
-    // }
-
-    for (let build of release.files) {
-      // // For debugging
-      // let paths = build.url.split('/');
-      // let extlen = build.extension.length + 1;
-      // let name = paths.at(-1);
-      // name = name.replace(`-${build.version}`, '');
-      // name = name.slice('julia-'.length);
-      // name = name.slice(0, -extlen);
-      // console.log(`name: ${name}`);
-
-      // console.log(`triplet: ${build.triplet}`);
-      // console.log(`arch: ${build.arch}`);
-      // console.log(`os: ${build.os}`);
-      // console.log(`kind: ${build.kind}`);
-      // console.log(`extension: ${build.extension}`);
-      // console.log(`version: ${build.version}`);
-
-      if (build.kind === 'installer') {
-        continue;
-      }
-
-      let arch = archMap[build.arch] || build.arch || '-';
-      let os = osMap[build.os] || build.os || '-';
-      let libc = '';
-      let hardMusl = /\b(musl)\b/.test(build.url);
-      if (hardMusl) {
-        libc = 'musl';
-      } else if (os === 'linux') {
-        libc = 'gnu';
-      }
-
-      let webiBuild = {
-        version: build.version,
-        _version: build.version,
-        lts: false,
-        channel: '', // autodetect by filename (-beta1, -alpha1, -rc1)
-        date: '1970-01-01', // the world may never know
-        os: os,
-        arch: arch,
-        libc: libc,
-        _musl: hardMusl,
-        ext: '', // let normalize run the split/test/join
-        hash: '-', // build.sha256 not ready to standardize this yet
-        download: build.url,
-      };
-      all.releases.push(webiBuild);
-    }
-  }
-
-  all.releases.sort(sortByVersion);
-
-  return all;
-}
-
-/**
- * @param {Object} a
- * @param {String} a.version
- * @param {Object} b
- * @param {String} b.version
- */
-function sortByVersion(a, b) {
-  let [aVer, aPre] = a.version.split('-');
-  let [bVer, bPre] = b.version.split('-');
-
-  let aVers = aVer.split('.');
-  let bVers = bVer.split('.');
-  for (let i = 0; i < 3; i += 1) {
-    aVers[i] = aVers[i].padStart(4, '0');
-    bVers[i] = bVers[i].padStart(4, '0');
-  }
-
-  aVer = aVers.join('.');
-  if (aPre) {
-    aVer += `-${aPre}`;
-  }
-  bVer = bVers.join('.');
-  if (bPre) {
-    bVer += `-${aPre}`;
-  }
-
-  if (aVer > bVer) {
-    return -1;
-  }
-  if (aVer < bVer) {
-    return 1;
-  }
-  return 0;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

k9s/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'derailed';
-var repo = 'k9s';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

keypairs/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'therootcompany';
-var repo = 'keypairs';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

kind/releases.js

@@ -1,28 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'kubernetes-sigs';
-var repo = 'kind';
-
-/******************************************************************************/
-/** Note: Delete this Comment!                                               **/
-/**                                                                          **/
-/** Need a an example that filters out miscellaneous release files?          **/
-/**   See `deno`, `gitea`, or `caddy`                                        **/
-/**                                                                          **/
-/******************************************************************************/
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

koji/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'cococonscious';
-var repo = 'koji';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

kubectx/releases.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'ahmetb';
-var repo = 'kubectx';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    let builds = [];
-
-    for (let build of all.releases) {
-      // this installs separately
-      if (build.name.includes('kubens')) {
-        continue;
-      }
-
-      // this is the legacy bash script
-      if (build.name === 'kubectx') {
-        continue;
-      }
-
-      builds.push(build);
-    }
-
-    all.releases = builds;
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

kubens/releases.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'ahmetb';
-var repo = 'kubectx';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    let builds = [];
-
-    for (let build of all.releases) {
-      // this installs separately
-      if (build.name.includes('kubectx')) {
-        continue;
-      }
-
-      // this is the legacy bash script
-      if (build.name === 'kubens') {
-        continue;
-      }
-
-      builds.push(build);
-    }
-
-    all.releases = builds;
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

lf/releases.js

@@ -1,25 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'gokcehan';
-var repo = 'lf';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all.releases = all.releases.map(function (r) {
-      // r21 -> 0.21.0
-      if (/^r/.test(r.version)) {
-        r.version = '0.' + r.version.replace('r', '') + '.0';
-      }
-      return r;
-    });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')._debug(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

lsd/install.sh

@@ -25,6 +25,22 @@ __init_lsd() {
 
         # mv ./lsd-*/lsd ~/.local/opt/lsd-v0.17.0/bin/lsd
         mv ./lsd-*/lsd "$pkg_src_cmd"
+
+        # install completions if present (autocomplete/{_lsd,lsd.fish,lsd.bash-completion})
+        if test -d ./lsd-*/autocomplete; then
+            mkdir -p "$pkg_src_dir/share/bash-completion/completions"
+            mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
+            mkdir -p "$pkg_src_dir/share/zsh/site-functions"
+            mv ./lsd-*/autocomplete/lsd.bash-completion "$pkg_src_dir/share/bash-completion/completions/lsd" 2>/dev/null || true
+            mv ./lsd-*/autocomplete/lsd.fish "$pkg_src_dir/share/fish/vendor_completions.d/lsd.fish" 2>/dev/null || true
+            mv ./lsd-*/autocomplete/_lsd "$pkg_src_dir/share/zsh/site-functions/_lsd" 2>/dev/null || true
+        fi
+
+        # install man page if present
+        if test -f ./lsd-*/lsd.1; then
+            mkdir -p "$pkg_src_dir/share/man/man1"
+            mv ./lsd-*/lsd.1 "$pkg_src_dir/share/man/man1/lsd.1"
+        fi
     }
 
     # pkg_get_current_version is recommended, but (soon) not required

lsd/releases.js

@@ -1,23 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'lsd-rs';
-var repo = 'lsd';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all.releases = all.releases.filter(function (rel) {
-      return !/(-msvc\.)|(\.deb$)/.test(rel.name);
-    });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

macos/releases.js

@@ -1,144 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-let oses = [
-  {
-    name: 'macOS Sierra',
-    version: '10.12.6',
-    date: '2018-09-26',
-    channel: 'beta',
-    url: 'https://support.apple.com/en-us/HT208202',
-  },
-  {
-    name: 'OS X El Capitan',
-    version: '10.11.6',
-    date: '2018-07-09',
-    lts: true,
-    channel: 'stable',
-    url: 'https://support.apple.com/en-us/HT206886',
-  },
-  {
-    name: 'OS X Yosemite',
-    version: '10.10.5',
-    date: '2017-07-19',
-    channel: 'beta',
-    url: 'https://support.apple.com/en-us/HT210717',
-  },
-];
-
-let headers = {
-  Connection: 'keep-alive',
-  'Cache-Control': 'max-age=0',
-  'Upgrade-Insecure-Requests': '1',
-  'User-Agent':
-    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36',
-  'Sec-Fetch-Dest': 'document',
-  Accept:
-    'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
-  'Sec-Fetch-Site': 'none',
-  'Sec-Fetch-Mode': 'navigate',
-  'Sec-Fetch-User': '?1',
-  'Accept-Language': 'en-US,en;q=0.9,sq;q=0.8',
-};
-
-/**
- * @param {typeof oses[0]} os
- */
-async function fetchReleasesForOS(os) {
-  let resp;
-  try {
-    resp = await Fetcher.fetch(os.url, {
-      headers: headers,
-    });
-  } catch (e) {
-    /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-    let err = e;
-    if (err.code === 'E_FETCH_RELEASES') {
-      err.message = `failed to fetch 'macos' release data: ${err.response.status} ${err.response.body}`;
-    }
-    throw e;
-  }
-
-  // Extract the download link
-  let match = resp.body.match(/(http[^>]+Install[^>]+\.dmg)/);
-  if (match) {
-    return match[1];
-  }
-}
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} arch
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} ext
- * @prop {String} [_filename]
- * @prop {String} hash
- * @prop {Boolean} lts
- * @prop {String} os
- */
-
-let osnames = ['macos', 'linux'];
-
-async function getDistributables() {
-  let all = {
-    _names: ['InstallOS'],
-    download: '',
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-  };
-
-  // Fetch data for each OS and populate the releases array
-  for (let os of oses) {
-    let download = await fetchReleasesForOS(os);
-    if (!download) {
-      continue;
-    }
-
-    // Add releases for macOS and Linux
-    for (let osname of osnames) {
-      let build = {
-        version: os.version,
-        lts: os.lts || false,
-        channel: os.channel || 'beta',
-        date: os.date,
-        os: osname,
-        arch: 'amd64',
-        ext: 'dmg',
-        hash: '-',
-        download: download,
-      };
-
-      all.releases.push(build);
-    }
-  }
-
-  // Sort releases
-  all.releases.sort(function (a, b) {
-    if (a.version === '10.11.6') {
-      return -1;
-    }
-
-    if (a.date > b.date) {
-      return 1;
-    } else if (a.date < b.date) {
-      return -1;
-    }
-
-    return 0;
-  });
-
-  return all;
-}
-
-module.exports = getDistributables;
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

mariadb/releases.js

@@ -1,181 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-let Releases = module.exports;
-
-let PRODUCT = `mariadb`;
-// `https://downloads.mariadb.org/rest-api/${PRODUCT}/${minor}/`
-// `https://downloads.mariadb.org/rest-api/mariadb/10.5/`
-// https://github.com/MariaDB/mariadb-documentation/issues/41
-
-Releases.latest = async function () {
-  let packages = [];
-  let versionData = await getVersionIds();
-  for (let verData of versionData.major_releases) {
-    let isVersion = /^\d+[.]\d+$/.test(verData.release_id);
-    if (!isVersion) {
-      continue;
-    }
-
-    let releaseData = await getReleases(verData.release_id);
-    let versions = Object.keys(releaseData.releases);
-    for (let ver of versions) {
-      let relData = releaseData.releases[ver];
-      for (let fileData of relData.files) {
-        let packageData = pluckData(verData, relData, fileData);
-        if (!packageData) {
-          continue;
-        }
-        packages.push(packageData);
-      }
-    }
-  }
-
-  let all = { releases: packages };
-  return all;
-};
-
-/** @type {Object.<String?, String>} */
-let channelsMap = {
-  // 'Long Term Support': 'stable',
-  // 'Short Term Support': 'stable',
-  // 'Rolling': null,
-  Stable: 'stable',
-  RC: 'rc',
-  Alpha: 'preview',
-  null: 'preview',
-};
-
-/** @type {Object.<String, String>} */
-let cpusMap = {
-  x86_64: 'amd64',
-};
-
-/**
- * @param {MajorRelease} verData
- * @param {Release} relData
- * @param {File} fileData
- */
-function pluckData(verData, relData, fileData) {
-  let lts =
-    verData.release_status === 'Stable' &&
-    verData.release_support_type === 'Long Term Support';
-  let cpu = fileData.cpu || '';
-  cpu = cpu.trim();
-
-  let isNotBinary = !fileData.os || !cpu; // "Source" or some such
-  if (isNotBinary) {
-    return null;
-  }
-
-  let isDebug = /debug/.test(fileData.file_name);
-  if (isDebug) {
-    return null;
-  }
-
-  let pkgData = {
-    name: fileData.file_name,
-    version: relData.release_id,
-    lts: lts,
-    channel: channelsMap[verData.release_status],
-    date: relData.date_of_release,
-    os: fileData.os?.toLowerCase(),
-    arch: cpusMap[cpu] || cpu,
-    hash: fileData.checksum.sha256sum,
-    download: fileData.file_download_url,
-  };
-
-  return pkgData;
-}
-
-/**
- * @typedef {String} ISODate - YYYY-MM-DD (ISO 8601 format)
- */
-
-/**
- * @typedef MajorRelease
- * @prop {String} release_id - version-like for stable versions, otherwise a title
- * @prop {String} release_name - same as id for MariaDB
- * @prop {String} release_status - Stable|RC|Alpha
- * @prop {String?} release_support_type - Long Term Support|Short Term Support|Rolling|null
- * @prop {ISODate?} release_eol_date
- */
-
-/**
- * @typedef MajorReleasesWrapper
- * @prop {Array<MajorRelease>} major_releases
- */
-
-/**
- * @typedef Release
- * @prop {String} release_id - "11.4.4" or "11.6.0 Vector"
- * @prop {String} release_name - "MariaDB Server 11.8.0 Preview"
- * @prop {ISODate} date_of_release
- * @prop {String} release_notes_url
- * @prop {String} change_log
- * @prop {Array<File>} files - release assets (packages, docs, etc)
- */
-
-/**
- * @typedef ReleasesWrapper
- * @prop {Object.<String, Release>} releases
- */
-
-/**
- * @typedef File
- * @prop {Number} file_id
- * @prop {String} file_name
- * @prop {String?} package_type - "gzipped tar file" or "ZIP file"
- * @prop {String?} os - "Linux" or "Windows"
- * @prop {String?} cpu - "x86_64" (or null)
- * @prop {Checksum} checksum
- * @prop {String} file_download_url
- * @prop {String?} signature
- * @prop {String} checksum_url
- * @prop {String} signature_url
- */
-
-/**
- * @typedef Checksum
- * @prop {String?} md5sum
- * @prop {String?} sha1sum
- * @prop {String?} sha256sum
- * @prop {String?} sha512sum
- */
-
-/**
- * @returns {Promise<MajorReleasesWrapper>}
- */
-async function getVersionIds() {
-  let url = `https://downloads.mariadb.org/rest-api/${PRODUCT}/`;
-  let resp = await Fetcher.fetch(url, {
-    headers: { Accept: 'application/json' },
-  });
-
-  let result = JSON.parse(resp.body);
-  return result;
-}
-
-/**
- * @param {String} verId
- * @returns {Promise<ReleasesWrapper>}
- */
-async function getReleases(verId) {
-  let url = `https://downloads.mariadb.org/rest-api/${PRODUCT}/${verId}`;
-  let resp = await Fetcher.fetch(url, {
-    headers: { Accept: 'application/json' },
-  });
-
-  let result = JSON.parse(resp.body);
-  return result;
-}
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    let normalize = require('../_webi/normalize.js');
-    all = normalize(all);
-    let json = JSON.stringify(all, null, 2);
-    console.info(json);
-  });
-}

monorel/releases.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'therootcompany';
-var repo = 'golib';
-
-let Releases = module.exports;
-
-Releases.latest = async function () {
-  let all = await github(null, owner, repo);
-
-  // This is a monorepo — keep only monorel releases and strip the
-  // path prefix from the version so normalize.js sees plain semver.
-  all.releases = all.releases.filter(function (rel) {
-    return rel.version.startsWith('tools/monorel/');
-  });
-  all.releases.forEach(function (rel) {
-    rel.version = rel.version.replace(/^tools\/monorel\//, '');
-  });
-
-  return all;
-};
-
-Releases.sample = async function () {
-  let normalize = require('../_webi/normalize.js');
-  let all = await Releases.latest();
-  all = normalize(all);
-  all.releases = all.releases.slice(0, 5);
-  return all;
-};
-
-if (module === require.main) {
-  (async function () {
-    let samples = await Releases.sample();
-    console.info(JSON.stringify(samples, null, 2));
-  })();
-}

mutagen/releases.js

@@ -1,18 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'mutagen-io';
-var repo = 'mutagen';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')._debug(all);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

node/releases.js

@@ -1,229 +0,0 @@
-'use strict';
-
-let Fetcher = require('../_common/fetcher.js');
-
-// https://blog.risingstack.com/update-nodejs-8-end-of-life-no-support/
-// 6 mos "current" + 18 mos LTS "active" +  12 mos LTS "maintenance"
-//let endOfLife = 3 * 366 * 24 * 60 * 60 * 1000;
-// If there have been no updates in 12 months, it's almost certainly end-of-life
-const END_OF_LIFE = 366 * 24 * 60 * 60 * 1000;
-
-// OSes
-/** @type {Object.<String, String>} */
-let osMap = {
-  osx: 'macos', // NOTE: filename is 'darwin'
-  linux: 'linux',
-  win: 'windows', // windows
-  sunos: 'sunos',
-  aix: 'aix',
-};
-
-// CPU architectures
-/** @type {Object.<String, String>} */
-let archMap = {
-  x64: 'amd64',
-  x86: 'x86',
-  ppc64: 'ppc64',
-  ppc64le: 'ppc64le',
-  arm64: 'arm64',
-  armv7l: 'armv7l',
-  armv6l: 'armv6l',
-  s390x: 's390x',
-};
-
-// file extensions
-/** @type {Object.<String, Array<String>>} */
-let pkgMap = {
-  pkg: ['pkg'],
-  //exe: ['exe'], // disable
-  '7z': ['7z'],
-  zip: ['zip'],
-  tar: ['tar.gz', 'tar.xz'],
-  // oddity - no os in download
-  msi: ['msi'],
-  // oddity - no pkg info
-  musl: ['tar.gz', 'tar.xz'],
-};
-
-/**
- * @typedef BuildInfo
- * @prop {String} version
- * @prop {String} [_version]
- * @prop {String} arch
- * @prop {String} channel
- * @prop {String} date
- * @prop {String} download
- * @prop {String} ext
- * @prop {String} [_filename]
- * @prop {String} [hash]
- * @prop {String} libc
- * @prop {Boolean} lts
- * @prop {String} os
- */
-
-async function getDistributables() {
-  let all = {
-    /** @type {Array<BuildInfo>} */
-    releases: [],
-    download: '',
-  };
-
-  /*
-  [
-        {
-            "version":"v20.3.1",
-            "date":"2023-06-20",
-            "files":["headers","linux-armv6l","linux-x64-musl","linux-x64-pointer-compression"],
-            "npm":"9.6.7",
-            "v8":"11.3.244.8",
-            "uv":"1.45.0",
-            "zlib":"1.2.13.1-motley",
-            "openssl":"3.0.9+quic",
-            "modules":"115",
-            "lts":false,
-            "security":true
-        },
-  ]
-  */
-
-  {
-    // Alternate: 'https://nodejs.org/dist/index.json',
-    let baseUrl = `https://nodejs.org/download/release`;
-
-    // Fetch official builds
-    let resp;
-    try {
-      resp = await Fetcher.fetch(`${baseUrl}/index.json`, {
-        headers: { Accept: 'application/json' },
-      });
-    } catch (e) {
-      /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-      let err = e;
-      if (err.code === 'E_FETCH_RELEASES') {
-        err.message = `failed to fetch 'node' release data: ${err.response.status} ${err.response.body}`;
-      }
-      throw e;
-    }
-    let data = JSON.parse(resp.body);
-
-    void transform(baseUrl, data);
-  }
-
-  {
-    let unofficialBaseUrl = `https://unofficial-builds.nodejs.org/download/release`;
-
-    // Fetch unofficial builds
-    let resp;
-    try {
-      resp = await Fetcher.fetch(`${unofficialBaseUrl}/index.json`, {
-        headers: { Accept: 'application/json' },
-      });
-    } catch (e) {
-      /** @type {Error & { code: string, response: { status: number, body: string } }} */ //@ts-expect-error
-      let err = e;
-      if (err.code === 'E_FETCH_RELEASES') {
-        err.message = `failed to fetch 'node' (unofficial) release data: ${err.response.status} ${err.response.body}`;
-      }
-      throw e;
-    }
-    let data = JSON.parse(resp.body);
-
-    transform(unofficialBaseUrl, data);
-  }
-
-  /**
-   * @param {String} baseUrl
-   * @param {Array<any>} builds
-   */
-  function transform(baseUrl, builds) {
-    for (let build of builds) {
-      let buildDate = new Date(build.date).valueOf();
-      let age = Date.now() - buildDate;
-      let maintained = age < END_OF_LIFE;
-      if (!maintained) {
-        continue;
-      }
-
-      let lts = false !== build.lts;
-
-      // skip 'v'
-      let vparts = build.version.slice(1).split('.');
-      let major = parseInt(vparts[0], 10);
-      let channel = 'stable';
-      let isEven = 0 === major % 2;
-      if (!isEven) {
-        channel = 'beta';
-      }
-
-      for (let file of build.files) {
-        if ('src' === file || 'headers' === file) {
-          continue;
-        }
-
-        let fileParts = file.split('-');
-
-        let osPart = fileParts[0];
-        let os = osMap[osPart];
-        let archPart = fileParts[1];
-        let arch = archMap[archPart];
-        let libc = '';
-        let pkgPart = fileParts[2];
-        let pkgs = pkgMap[pkgPart];
-        if (!pkgPart) {
-          pkgs = pkgMap.tar;
-        }
-        if (!pkgs?.length) {
-          continue;
-        }
-
-        let extra = '';
-        let muslNative;
-        if (fileParts[2] === 'musl') {
-          extra = '-musl';
-          muslNative = true;
-          libc = 'musl';
-        } else if (os === 'linux') {
-          libc = 'gnu';
-        }
-
-        if (osPart === 'osx') {
-          osPart = 'darwin';
-        }
-
-        for (let pkg of pkgs) {
-          let filename = `node-${build.version}-${osPart}-${archPart}${extra}.${pkg}`;
-          if ('msi' === pkg) {
-            filename = `node-${build.version}-${archPart}${extra}.${pkg}`;
-          }
-          let downloadUrl = `${baseUrl}/${build.version}/${filename}`;
-
-          let release = {
-            name: filename,
-            version: build.version,
-            lts: lts,
-            channel: channel,
-            date: build.date,
-            os: os,
-            arch: arch,
-            ext: pkg,
-            download: downloadUrl,
-            libc: libc,
-          };
-
-          all.releases.push(release);
-        }
-      }
-    }
-  }
-
-  return all;
-}
-module.exports = getDistributables;
-
-if (module === require.main) {
-  getDistributables().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-    //console.info(JSON.stringify(all, null, 2));
-  });
-}

ollama/releases.js

@@ -1,59 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'jmorganca';
-var repo = 'ollama';
-
-module.exports = async function () {
-  let all = await github(null, owner, repo);
-
-  let releases = [];
-  for (let rel of all.releases) {
-    // this is a janky, sudo-wantin' .app
-    let isJank = rel.name.startsWith('Ollama-darwin');
-    if (isJank) {
-      continue;
-    }
-
-    let isUniversal = rel.name === 'ollama-darwin';
-    if (isUniversal) {
-      let x64 = Object.assign({ arch: 'x86_64' }, rel);
-      releases.push(x64);
-
-      rel.arch = 'aarch64';
-    }
-
-    let isROCm = rel.name.includes('-rocm');
-    if (isROCm) {
-      Object.assign(rel, { arch: 'x86_64_rocm' });
-    }
-
-    let oddballs = {
-      tgz: 'tar.gz',
-      tbz2: 'tar.bz2',
-      txz: 'tar.xz',
-    };
-    let oddExts = Object.keys(oddballs);
-    for (let oddExt of oddExts) {
-      let isOddball = rel.name.endsWith(`.${oddExt}`);
-      if (isOddball) {
-        let ext = oddballs[oddExt];
-        rel.name = rel.name.replace(`.${oddExt}`, `.${ext}`);
-        rel.ext = ext;
-      }
-    }
-
-    releases.push(rel);
-  }
-  all.releases = releases;
-
-  return all;
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-    //console.info(JSON.stringify(all, null, 2));
-  });
-}

ots/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'emdneto';
-var repo = 'otsgo';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

pandoc/install.sh

@@ -25,6 +25,12 @@ __init_pandoc() {
 
         # mv ./pandoc-*/pandoc ~/.local/opt/pandoc-v2.10.1/bin/pandoc
         mv ./pandoc-*/bin/pandoc "$pkg_src_cmd"
+
+        # install man pages if present (share/man/man1/pandoc*.1.gz)
+        if test -d ./pandoc-*/share/man; then
+            mkdir -p "$pkg_src_dir/share"
+            mv ./pandoc-*/share/man "$pkg_src_dir/share/man"
+        fi
     }
 
     # pkg_get_current_version is recommended, but (soon) not required

pandoc/releases.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'jgm';
-var repo = 'pandoc';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

pathman/releases.js

@@ -1,28 +0,0 @@
-'use strict';
-
-var github = require('../_common/gitea.js');
-var owner = 'root';
-var repo = 'pathman';
-var baseurl = 'https://git.rootprojects.org';
-
-module.exports = function () {
-  return github(null, owner, repo, baseurl).then(function (all) {
-    all.releases = all.releases.filter(function (release) {
-      release._filename = release.name;
-
-      let isOldAlias = release.name.includes('armv8');
-      if (isOldAlias) {
-        return false;
-      }
-
-      return true;
-    });
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

pg-essentials/README.md

@@ -0,0 +1,203 @@
+---
+title: pg-essentials
+homepage: https://github.com/bnnanet/pg-essentials
+tagline: |
+  pg-essentials: client and server scripts for working with postgres
+---
+
+To update or switch versions, run `webi pg-essentials@stable` (or `@v1.0.0`,
+`@beta`, etc).
+
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.local/bin/
+~/.local/opt/pg-essentials/
+~/.pgpass
+~/.psqlrc
+~/.config/psql/psqlrc.sql
+~/.config/psql/history
+```
+
+## Cheat Sheet
+
+> `pg-essentials` includes scripts to manage credentials, backups, and
+> preferences.
+
+```sh
+psql-store-credential 'postgres://my-userdb:my-token@my-host:5432/my-userdb'
+psql-backup 'postgres://my-userdb@my-host:5432/my-userdb'
+```
+
+```sh
+pg-register-service '5432'
+pg-addgroup 'hostssl' 'remote_users' 5432
+pg-adduser 'my-user-prefix' '5432' 'remote_users'
+pg-passwd 'my-user-prefix-and-suffix' 5432
+```
+
+### Client Scripts
+
+#### How to Store Credentials
+
+This will parse the PG URL and put it in the correct credential format in
+`~/.pgpass`.
+
+```sh
+psql-store-credential 'postgres://my-userdb:my-token@my-host:5432/my-userdb'
+```
+
+This is the same as manually editing `~/.pgpass` to add
+
+```text
+# export PGPASSFILE="$HOME/.pgpass"
+# hostname:port:database:username:password
+my-host:5432:my-userdb:my-userdb:my-token
+```
+
+#### How to Backup
+
+This uses `pg_dump` to create an easy-to-restore backup (using the correct
+permission options), with the schema and data separated.
+
+```sh
+psql-backup 'postgres://my-userdb@my-host:5432/my-userdb'
+```
+
+Or with positional arguments:
+
+```sh
+psql-backup 'my-userdb' 'my-host' 5432 'my-userdb'
+```
+
+```text
+my-userdb.schema.drop.sql  # drops and then creates schema
+my-userdb.schema.sql       # creates schema, without dropping
+my-userdb.data.sql         # inserts data
+```
+
+This is the same as:
+
+```sh
+pg_dump --no-privileges --no-owner --schema-only --clean \
+    --username 'my-userdb' --no-password --host 'my-host' --port 5432 \
+    -f ./my-userdb.schema.drop.sql 'my-userdb'
+
+pg_dump --no-privileges --no-owner --schema-only \
+    --username 'my-userdb' --no-password --host 'my-host' --port 5432 \
+    -f ./my-userdb.schema.sql 'my-userdb'
+
+pg_dump --no-privileges --no-owner --data-only \
+    --username 'my-userdb' --no-password --host 'my-host' --port 5432 \
+    -f ./my-userdb.data.sql 'my-userdb'
+```
+
+### Server Scripts
+
+These assume a conflict-free installation of postgres at
+`~/.local/share/postgres/var/`.
+
+The scripts can easily be manually modified for other locations.
+
+#### How to Register Service
+
+```sh
+pg-register-service '5432'
+```
+
+This is the same as
+
+```sh
+curl https://webi.sh/serviceman | sh
+source ~/.config/envman/PATH.env
+
+mkdir -p ~/.local/share/postgres
+serviceman add --name 'postgres' -- \
+    postgres -D ~/.local/share/postgres/var -p 5432
+```
+
+#### How to add Remote Role (Group)
+
+This will add a role (group) which allows users (named the same as their
+database name) to access the pg database remotely, using TLS with SNI (ALPN will
+be set to 'postgresql' and must be explicitly accepted by proxies).
+
+```sh
+pg-addgroup 'hostssl' 'remote_users' 5432
+```
+
+Other connection types:
+
+```sh
+pg-addgroup 'host' 'subnet_users' 5432
+pg-addgroup 'localhost' 'local_users' 5432
+pg-addgroup 'local' 'unix_users' 5432
+```
+
+This is the same as adding a remote users role and editing
+`~/.local/share/postgres/var/pg_hba.conf`
+
+```sql
+CREATE ROLE "remote_users" NOLOGIN;
+```
+
+```ini
+hostssl sameuser         +remote_users        0.0.0.0/0               scram-sha-256
+hostssl sameuser         +remote_users        ::0/0                   scram-sha-256
+```
+
+#### How to add Remote User
+
+You must first add a group for the user to belong to.
+
+This will create a user and database of the same name, with the given prefix
+(followed by a random suffix), as a member of 'remote_users':
+
+```sh
+pg-addgroup 'hostssl' 'remote_users' 5432
+pg-adduser 'my-user-prefix' 5432 'remote_users'
+```
+
+This is the same as generating a random suffix and password (ex: using `uuidgen`
+or `xxd -l 16 -ps /dev/urandom`), and creating the `DATABASE`, `ROLE`, and
+granting `PRIVILEGES`:
+
+```sql
+CREATE DATABASE "my-user-prefix-1234";
+CREATE ROLE "my-user-prefix-1234" LOGIN INHERIT IN ROLE "remote_users" ENCRYPTED PASSWORD 'supersecret';
+GRANT ALL PRIVILEGES ON DATABASE "my-user-prefix-1234" to "my-user-prefix-1234";
+```
+
+Note: the password is NOT encrypted, just hashed - a misnomer from days of yore
+
+#### How to Set a User's Password
+
+This generates a new random password for the user/db.
+
+```sh
+pg-passwd 'my-user-prefix-and-suffix'
+```
+
+This is the same as generating a random password and running the following:
+
+```sql
+ALTER USER "my-user-prefix-and-suffix" WITH PASSWORD 'supersecret';
+```
+
+### Building Postgres from Source
+
+These scripts will build postgres in `~/relocatable`, from source.
+
+```sh
+pg-build "$(hostname)" 18.1
+```
+
+Or use the platform-specific scripts directly:
+
+```sh
+pg-build-linux "$(hostname)" 18.1
+pg-build-macos "$(hostname)" 18.1
+```

pg-essentials/install.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+
+__init_pg_essentials() {
+    set -e
+    set -u
+
+    #########################
+    # Install pg-essentials #
+    #########################
+
+    # Every package should define these 6 variables
+    pkg_cmd_name="pg-essentials"
+
+    pkg_dst_cmd="$HOME/.local/bin/psql-backup"
+    pkg_dst="$pkg_dst_cmd"
+
+    pkg_src_cmd="$HOME/.local/opt/pg-essentials-v$WEBI_VERSION/psql-backup"
+    pkg_src_bin="$HOME/.local/opt/pg-essentials-v$WEBI_VERSION"
+    pkg_src_dir="$HOME/.local/opt/pg-essentials-v$WEBI_VERSION"
+    pkg_src="$pkg_src_cmd"
+
+    pkg_install() {
+        rm -rf "${pkg_src_dir}"
+        # mv ./bnnanet-pg-essentials-* "$HOME/.local/opt/pg-essentials-v1.0.0"
+        mv ./*"$pkg_cmd_name"*/ "${pkg_src_dir}"
+    }
+
+    pkg_link() {
+        (
+            cd ~/.local/opt/ || return 1
+            rm -rf ./pg-essentials
+            ln -s "pg-essentials-v$WEBI_VERSION" 'pg-essentials'
+        )
+
+        (
+            mkdir -p ~/.local/bin/
+            cd ~/.local/opt/pg-essentials/ || return 1
+            for b_file in pg-*; do
+                rm -rf ../../bin/"${b_file}"
+                ln -s "../opt/pg-essentials-v$WEBI_VERSION/${b_file}" ../../bin/
+            done
+            for b_file in psql-*; do
+                rm -rf ../../bin/"${b_file}"
+                ln -s "../opt/pg-essentials-v$WEBI_VERSION/${b_file}" ../../bin/
+            done
+        )
+    }
+
+    pkg_get_current_version() {
+        # 'psql-backup -V' has output in this format:
+        #       psql-backup v1.0.0 - creates portable (across instances) SQL schema & data backups
+        #
+        #       USAGE
+        #           psql-backup <user> [host] [port] [dbname]
+        #
+        #       ...
+        # This trims it down to just the version number:
+        #       1.0.0
+        psql-backup --version 2> /dev/null | head -n 1 | cut -d' ' -f2 | sed 's:^v::'
+    }
+
+}
+
+__init_pg_essentials

pg-essentials/releases.conf

@@ -0,0 +1 @@
+git_url = https://github.com/bnnanet/pg-essentials.git

pg/releases.js

@@ -1,50 +0,0 @@
-'use strict';
-
-let Releases = module.exports;
-
-var Github = require('../_common/github.js');
-var owner = 'bnnanet';
-var repo = 'postgresql-releases';
-
-Releases.latest = async function () {
-  let all = await Github.getDistributables(null, owner, repo);
-
-  /** @type {Array<Awaited<ReturnType<typeof Github.getDistributables>>>[Number]["releases"]} */
-  let distributables = [];
-  for (let dist of all.releases) {
-    let isBaseline = dist.name.includes('baseline');
-    if (isBaseline) {
-      continue;
-    }
-
-    let isServer = dist.name.includes('postgres');
-    if (!isServer) {
-      continue;
-    }
-
-    // REL_17_0 => 17.0
-    dist.version = dist.version.replace(/REL_/g, '');
-    dist.version = dist.version.replace(/_/g, '.');
-
-    let isHardMusl = dist.name.includes('musl');
-    if (isHardMusl) {
-      Object.assign(dist, { libc: 'musl', _musl: true });
-    }
-    distributables.push(dist);
-  }
-
-  all.releases = distributables;
-
-  Object.assign(all, { _names: ['postgres', 'postgresql', 'pgsql', 'psql'] });
-
-  return all;
-};
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    let normalize = require('../_webi/normalize.js');
-    all = normalize(all);
-    let json = JSON.stringify(all, null, 2);
-    console.info(json);
-  });
-}

postgres/README.md

@@ -5,6 +5,8 @@ tagline: |
   PostgreSQL: The World's Most Advanced Open Source Relational Database.
 ---
 
+TODO
+
 To update or switch versions, run `webi postgres@stable` (or `@v10`, `@beta`,
 etc).
 
@@ -47,7 +49,7 @@ To login: \
 # as Postgres admin
 psql "postgres://postgres:postgres@localhost:5432/postgres"
 
-# as remote user
+# as remote user (over standard TLS and SNI, with ALPN set to 'postgresql')
 psql "postgres://db-xxxx@pg-1.example.com:5432/db-xxxx?sslmode=require&sslnegotiation=direct"
 ```
 

postgres/releases.js

@@ -1,129 +0,0 @@
-'use strict';
-
-let Releases = module.exports;
-
-var Github = require('../_common/github.js');
-var owner = 'bnnanet';
-var repo = 'postgresql-releases';
-
-let originalReleases = {
-  _names: ['PostgreSQL', 'postgresql', 'Postgres', 'postgres', 'binaries'],
-  releases: [
-    {
-      name: 'postgresql-10.12-1-linux-x64-binaries.tar.gz',
-      version: '10.12',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'linux',
-      arch: 'amd64',
-      libc: 'gnu',
-      ext: 'tar',
-      download: '',
-    },
-    {
-      name: 'postgresql-10.12-1-linux-binaries.tar.gz',
-      version: '10.12',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'linux',
-      arch: 'x86',
-      libc: 'gnu',
-      ext: 'tar',
-      download: '',
-    },
-    {
-      name: 'postgresql-10.12-1-osx-binaries.zip',
-      version: '10.12',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'macos',
-      arch: 'amd64',
-      ext: 'zip',
-      download: '',
-    },
-    {
-      name: 'postgresql-10.13-1-osx-binaries.zip',
-      version: '10.13',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'macos',
-      arch: 'amd64',
-      ext: 'zip',
-      download: '',
-    },
-    {
-      name: 'postgresql-11.8-1-osx-binaries.zip',
-      version: '11.8',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'macos',
-      arch: 'amd64',
-      ext: 'zip',
-      download: '',
-    },
-    {
-      name: 'postgresql-12.3-1-osx-binaries.zip',
-      version: '12.3',
-      lts: false,
-      channel: 'stable',
-      date: '',
-      os: 'macos',
-      arch: 'amd64',
-      ext: 'zip',
-      download: '',
-    },
-  ].map(function (rel) {
-    //@ts-ignore - it's a special property
-    rel._version = `${rel.version}-1`;
-    rel.download = `https://get.enterprisedb.com/postgresql/${rel.name}?ls=Crossover&type=Crossover`;
-    return rel;
-  }),
-  download: '',
-};
-
-Releases.latest = async function () {
-  let all = await Github.getDistributables(null, owner, repo);
-
-  /** @type {Array<Awaited<ReturnType<typeof Github.getDistributables>>>[Number]["releases"]} */
-  let distributables = [];
-  for (let dist of all.releases) {
-    console.log(dist);
-    console.log(dist.name, 'niche', /psql|baseline/.test(dist.name));
-    let isNiche = /psql|baseline/.test(dist.name);
-    if (isNiche) {
-      continue;
-    }
-
-    // REL_17_0 => 17.0
-    dist.version = dist.version.replace(/REL_/g, '');
-    dist.version = dist.version.replace(/_/g, '.');
-
-    let isHardMusl = dist.name.includes('musl');
-    if (isHardMusl) {
-      Object.assign(dist, { libc: 'musl', _musl: true });
-    }
-    distributables.push(dist);
-  }
-
-  all.releases = distributables;
-
-  Object.assign(all, { _names: originalReleases._names });
-  //@ts-ignore - mixing old and new release types
-  all.releases = all.releases.concat(originalReleases.releases);
-
-  return all;
-};
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    let normalize = require('../_webi/normalize.js');
-    all = normalize(all);
-    let json = JSON.stringify(all, null, 2);
-    console.info(json);
-  });
-}

psql/README.md

@@ -38,7 +38,7 @@ psql "postgres://db-xxxx:secret123@pg-1.example.com:5432/db-xxxx"
 ```
 
 For remote / public networks: \
-(with `sslmode` & `sslnegotiation`)
+(with `sslmode` & `sslnegotiation` for standard TLS and SNI, with ALPN set to 'postgresql')
 
 ```sh
 psql "postgres://db-xxxx@pg-1.example.com:5432/db-xxxx?sslmode=require&sslnegotiation=direct"

psql/releases.js

@@ -1,50 +0,0 @@
-'use strict';
-
-let Releases = module.exports;
-
-var Github = require('../_common/github.js');
-var owner = 'bnnanet';
-var repo = 'postgresql-releases';
-
-Releases.latest = async function () {
-  let all = await Github.getDistributables(null, owner, repo);
-
-  /** @type {Array<Awaited<ReturnType<typeof Github.getDistributables>>>[Number]["releases"]} */
-  let distributables = [];
-  for (let dist of all.releases) {
-    let isBaseline = dist.name.includes('baseline');
-    if (isBaseline) {
-      continue;
-    }
-
-    let isClient = dist.name.includes('psql');
-    if (!isClient) {
-      continue;
-    }
-
-    // REL_17_0 => 17.0
-    dist.version = dist.version.replace(/REL_/g, '');
-    dist.version = dist.version.replace(/_/g, '.');
-
-    let isHardMusl = dist.name.includes('musl');
-    if (isHardMusl) {
-      Object.assign(dist, { libc: 'musl', _musl: true });
-    }
-    distributables.push(dist);
-  }
-
-  all.releases = distributables;
-
-  Object.assign(all, { _names: ['postgres', 'postgresql', 'pgsql', 'psql'] });
-
-  return all;
-};
-
-if (module === require.main) {
-  Releases.latest().then(function (all) {
-    let normalize = require('../_webi/normalize.js');
-    all = normalize(all);
-    let json = JSON.stringify(all, null, 2);
-    console.info(json);
-  });
-}

pwsh/releases.js

@@ -1,51 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'powershell';
-var repo = 'powershell';
-
-let ODDITIES = ['-fxdependent'];
-
-function isOdd(build) {
-  for (let oddity of ODDITIES) {
-    let isOddity = build.name.includes(oddity);
-    if (isOddity) {
-      return true;
-    }
-  }
-}
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    // remove checksums and .deb
-    all.releases = all.releases.filter(function (rel) {
-      let odd = isOdd(rel);
-      if (odd) {
-        return false;
-      }
-
-      let isPreview = rel.name.includes('-preview.');
-      if (isPreview) {
-        rel.channel = 'beta';
-      }
-
-      let isMusl = rel.download.match(/(\b|_)(musl|alpine)(\b|_)/i);
-      if (isMusl) {
-        // not a fully static build, not gnu-compatible
-        rel.libc = 'musl';
-      }
-
-      return true;
-    });
-
-    all._names = ['PowerShell', 'powershell'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    console.info(JSON.stringify(all));
-  });
-}

rclone/releases.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'rclone';
-var repo = 'rclone';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    all.releases = all.releases.slice(0, 10);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}

rg/install.sh

@@ -26,6 +26,22 @@ __init_rg() {
         # mv ./ripgrep-*/rg ~/.local/opt/rg-v12.1.1/bin/rg
         mv ./ripgrep-*/rg "$pkg_src_cmd"
 
+        # install completions if present (complete/_rg, complete/rg.bash, complete/rg.fish)
+        if test -d ./ripgrep-*/complete; then
+            mkdir -p "$pkg_src_dir/share/bash-completion/completions"
+            mkdir -p "$pkg_src_dir/share/fish/vendor_completions.d"
+            mkdir -p "$pkg_src_dir/share/zsh/site-functions"
+            mv ./ripgrep-*/complete/rg.bash "$pkg_src_dir/share/bash-completion/completions/rg" 2>/dev/null || true
+            mv ./ripgrep-*/complete/rg.fish "$pkg_src_dir/share/fish/vendor_completions.d/rg.fish" 2>/dev/null || true
+            mv ./ripgrep-*/complete/_rg "$pkg_src_dir/share/zsh/site-functions/_rg" 2>/dev/null || true
+        fi
+
+        # install man page if present
+        if test -f ./ripgrep-*/doc/rg.1; then
+            mkdir -p "$pkg_src_dir/share/man/man1"
+            mv ./ripgrep-*/doc/rg.1 "$pkg_src_dir/share/man/man1/rg.1"
+        fi
+
         if ! [ -e ~/.ripgreprc ]; then
             touch ~/.ripgreprc
         fi

rg/releases.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var github = require('../_common/github.js');
-var owner = 'BurntSushi';
-var repo = 'ripgrep';
-
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
-    all._names = ['ripgrep', 'rg'];
-    return all;
-  });
-};
-
-if (module === require.main) {
-  module.exports().then(function (all) {
-    all = require('../_webi/normalize.js')(all);
-    // just select the first 5 for demonstration
-    all.releases = all.releases.slice(0, 5);
-    console.info(JSON.stringify(all, null, 2));
-  });
-}