fix(webi): handle special chars in USERPROFILE path and detect download failures

Co-authored-by: coolaj86 <122831+coolaj86@users.noreply.github.com>

.github/ISSUE_TEMPLATE/new_installer.md

@@ -35,15 +35,18 @@ info, and doing a find and replace on a few file system path names.
    ```
 2. Copy the example template and update with info from Official Releases:
    <https://github.com/___CHANGE/ME___/releases>
+
    ```bash
    rsync -av _example/ CHANGE-ME/
    ```
+
    - [ ] update `CHANGE-ME/release.js` to use the official repo
    - [ ] Learn how `CHANGE-ME` unpacks (i.e. as a single file? as a .tar.gz? as
          a .tar.gz with a folder named CHANGE-ME?)
    - [ ] find and replace to change the name
      - [ ] update `CHANGE-ME/install.sh` (see `bat` and `jq` as examples)
      - [ ] update `CHANGE-ME/install.ps1` (see `bat` and `jq` as examples)
+
 3. Needs an updated tagline and cheat sheet
    - [ ] update `CHANGE-ME/README.md`
      - [ ] official URL

AGENTS.md

@@ -0,0 +1,372 @@
+# Webi Installers — Agent Guide
+
+Webi installs dev tools to `~/.local/` without sudo. Each installer is a small
+package of 3-4 files. This guide tells you how to create and modify them.
+
+## Why Webi Exists
+
+Webi makes tool installation trivially repeatable for people who aren't
+sysadmins — freelance clients, junior devs, anyone who shouldn't have to care
+about PATH, permissions, or platform differences. Three things matter:
+
+1. **Install without friction.** No sudo, no manual PATH edits, no "necessary
+   but unimportant" steps leaking into the experience.
+2. **Know where things are.** The Files section tells you exactly what got
+   created or modified. Nothing should be mysterious.
+3. **Copy-paste recipes.** The cheat sheet is what you'd send someone less
+   experienced than yourself instead of a project's full README — scannable,
+   concrete, easy to reference by name.
+
+## Quick Start: Adding a New Installer
+
+1. Identify the **package type** (see [Categories](#categories) below)
+2. Find an existing installer of the same type to use as a template
+3. Create `<name>/releases.js`, `install.sh`, `install.ps1`, `README.md`
+4. Test with the command in [Testing releases.js](#testing-releasesjs)
+5. Run formatters before committing (see [Code Style](#code-style))
+
+## Directory Layout
+
+```
+<package-name>/
+  README.md          # YAML frontmatter + docs
+  releases.js        # Fetches release metadata (Node.js)
+  install.sh         # POSIX shell installer (macOS/Linux)
+  install.ps1        # PowerShell installer (Windows) — optional
+```
+
+Key infrastructure directories (do not modify without good reason):
+
+- `_webi/` — bootstrap templates, `normalize.js` (auto-detects OS/arch/ext from
+  filenames)
+- `_common/` — shared JS: `github.js`, `githubish.js`, `gitea.js`, `fetcher.js`
+- `_example/` — canonical template for new packages
+- `_examples/` — specialized templates (goreleaser, xz-compressed)
+
+## Categories
+
+Ref: <https://github.com/webinstall/webi-installers/issues/412>
+
+| Type  | Description                            | Template to copy |
+| ----- | -------------------------------------- | ---------------- |
+| `bin` | Single binary in tar/zip               | `koji`, `delta`  |
+| `bin` | Single bare binary (no archive)        | `arc`, `shfmt`   |
+| `bin` | Goreleaser-style archives              | `keypairs`       |
+| 📦    | Self-contained package (bin/man/share) | `node`, `go`     |
+| 📂    | Multiple binaries/scripts              | `pg`             |
+| 🔗    | Alias/redirect to another package      | `ripgrep` → `rg` |
+| 📝    | Bespoke / custom install               | `rustlang`       |
+
+## releases.js
+
+Fetches release metadata and returns a normalized object. Most packages use
+GitHub releases:
+
+```js
+'use strict';
+
+var github = require('../_common/github.js');
+var owner = 'OWNER';
+var repo = 'REPO';
+
+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);
+  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));
+  })();
+}
+```
+
+### Common release transformations
+
+**Strip version prefix** (monorepo or tool-prefixed tags):
+
+```js
+// e.g. "tools/monorel/v0.6.5" → "v0.6.5"
+rel.version = rel.version.replace(/^tools\/monorel\//, '');
+
+// e.g. "cli-v1.2.3" → "v1.2.3"
+rel.version = rel.version.replace(/^cli-/, '');
+```
+
+**Filter releases** (monorepo with multiple tools, or unwanted assets):
+
+```js
+all.releases = all.releases.filter(function (rel) {
+  // Keep only releases for this tool
+  return rel.version.startsWith('tools/monorel/');
+});
+```
+
+Apply transformations inside `Releases.latest`, before returning `all`.
+
+**Available sources** beyond `github.js`:
+
+- `_common/gitea.js` — Gitea servers
+- `_common/git-tag.js` — Git tag listing
+- Custom fetch from any JSON API (see `go/releases.js`, `terraform/releases.js`)
+
+### Testing releases.js
+
+```sh
+node -e "
+  let Releases = require('./<name>/releases.js');
+  Releases.sample().then(function (all) {
+    console.log(JSON.stringify(all, null, 2));
+  });
+"
+```
+
+Verify: versions are clean semver (`0.6.5` not `tools/monorel/v0.6.5`), OS/arch
+detected correctly, download URLs resolve.
+
+## install.sh
+
+POSIX shell (`sh`, not bash). Always wrapped in a function:
+
+```sh
+#!/bin/sh
+# shellcheck disable=SC2034
+
+set -e
+set -u
+
+__init_pkgname() {
+    # These 6 variables are required
+    pkg_cmd_name="cmd"
+
+    pkg_dst_cmd="$HOME/.local/bin/cmd"
+    pkg_dst="$pkg_dst_cmd"
+
+    pkg_src_cmd="$HOME/.local/opt/cmd-v$WEBI_VERSION/bin/cmd"
+    pkg_src_dir="$HOME/.local/opt/cmd-v$WEBI_VERSION"
+    pkg_src="$pkg_src_cmd"
+
+    pkg_install() {
+        mkdir -p "$(dirname "$pkg_src_cmd")"
+        mv ./cmd "$pkg_src_cmd"
+    }
+
+    pkg_get_current_version() {
+        cmd --version 2> /dev/null | head -n 1 | cut -d' ' -f2
+    }
+}
+
+__init_pkgname
+```
+
+### Framework variables available in install.sh
+
+Set by the webi bootstrap (`_webi/package-install.tpl.sh`):
+
+| Variable        | Example             | Description           |
+| --------------- | ------------------- | --------------------- |
+| `WEBI_VERSION`  | `1.2.3`             | Selected version      |
+| `WEBI_PKG_URL`  | `https://...`       | Download URL          |
+| `WEBI_PKG_FILE` | `foo-v1.2.3.tar.gz` | Download filename     |
+| `WEBI_OS`       | `linux`             | Detected OS           |
+| `WEBI_ARCH`     | `amd64`             | Detected architecture |
+| `WEBI_EXT`      | `tar.gz`            | Archive extension     |
+| `WEBI_CHANNEL`  | `stable`            | Release channel       |
+| `PKG_NAME`      | `foo`               | Package name          |
+
+### Override functions
+
+| Function                    | Purpose                                       |
+| --------------------------- | --------------------------------------------- |
+| `pkg_install()`             | **Required.** Move files to `$pkg_src`        |
+| `pkg_get_current_version()` | Parse installed version from command output   |
+| `pkg_post_install()`        | Post-install setup (git config, shell config) |
+| `pkg_done_message()`        | Custom completion message                     |
+| `pkg_link()`                | Override default symlink behavior             |
+| `pkg_pre_install()`         | Custom pre-install logic                      |
+
+### Framework helper functions
+
+| Function                 | Purpose                            |
+| ------------------------ | ---------------------------------- |
+| `webi_download()`        | Download package if not cached     |
+| `webi_extract()`         | Extract archive by extension       |
+| `webi_path_add <dir>`    | Add to PATH via envman             |
+| `webi_link()`            | Create versioned symlinks          |
+| `webi_check_installed()` | Check if version already installed |
+
+### pkg_install patterns
+
+**Bare binary in archive root:**
+
+```sh
+mv ./cmd "$pkg_src_cmd"
+```
+
+**Binary in a subdirectory (goreleaser-style `cmd-OS-arch/cmd`):**
+
+```sh
+mv ./cmd-*/cmd "$pkg_src_cmd"
+```
+
+**Flexible detection (handles multiple archive layouts):**
+
+```sh
+if test -f ./cmd; then
+    mv ./cmd "$pkg_src_cmd"
+elif test -e ./cmd-*/cmd; then
+    mv ./cmd-*/cmd "$pkg_src_cmd"
+elif test -e ./cmd-*; then
+    mv ./cmd-* "$pkg_src_cmd"
+fi
+```
+
+## install.ps1
+
+PowerShell for Windows. Uses `$Env:` variables. See `_example/install.ps1` for
+the full template. Key differences from install.sh:
+
+- Paths use backslashes, commands end in `.exe`
+- `$Env:USERPROFILE` instead of `$HOME`
+- `Test-Path`, `Move-Item`, `Copy-Item` instead of shell equivalents
+- Downloads go to `$Env:USERPROFILE\Downloads\webi\`
+- Temp work in `.local\tmp`, use `Push-Location`/`Pop-Location`
+- Symlinks done via `Copy-Item` (not actual symlinks)
+
+## README.md
+
+````markdown
+---
+title: toolname
+homepage: https://github.com/owner/repo
+tagline: |
+  toolname: A short one-line description.
+---
+
+To update or switch versions, run `webi toolname@stable` (or `@v2`, `@beta`,
+etc).
+
+### Files
+
+These are the files that are created and/or modified with this installer:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/toolname
+~/.local/opt/toolname-VERSION/bin/toolname
+```
+
+## Cheat Sheet
+
+> `toolname` does X. Brief description.
+
+### How to use toolname
+
+```sh
+toolname --example
+```
+````
+
+Note: **Files goes above Cheat Sheet**, not inside it.
+
+### Cheat Sheet tone and style
+
+Webi cheat sheets are **opinionated quick-reference guides**, not comprehensive
+documentation. Think "colleague's sticky note" — not the project's official
+README.
+
+The tool is the topic, but **the problem is the reason**. Cheat sheets are
+organized around tasks the reader already wants to do — the tool is how they get
+there. Headings reference the tool (the reader came to this page on purpose),
+but the content solves the underlying problem completely:
+
+- "How to reverse proxy to Node" (caddy knowledge, not just node)
+- "How to run a Node app as a System Service" (serviceman knowledge)
+- "How to Enable Secure Remote Postgres Access" (openssl, pg_hba.conf, systemd)
+- "How to manually configure git to use delta" (gitconfig, not delta flags)
+- "How to make fish the default shell in iTerm2" (iTerm2 knowledge, not fish)
+
+The reader's question is "how do I do X?" and the cheat sheet answers it
+completely — including configs, adjacent tools, and platform-specific
+variations. A goreleaser cheat sheet teaches you goreleaser YAML. A postgres
+cheat sheet teaches you pg_hba.conf, openssl certs, and systemd units.
+
+Cheat sheets cross tool boundaries freely. Node's references caddy, serviceman,
+setcap-netbind, GitHub Actions. Postgres references serviceman, openrc, launchd.
+They link to each other's webi pages. The scope is "everything you need to
+accomplish this task," not "everything this one binary does."
+
+They show the actual files and configs that matter — not documentation _about_
+configs, but the configs themselves, copy-pasteable, with inline comments
+explaining the non-obvious parts.
+
+**Guidelines:**
+
+- **Show the 3-5 things someone will actually do**, with copy-pasteable
+  commands. Skip exhaustive flag lists and API docs.
+- **Lead with practical integration.** Show the exact `git config` lines, the
+  exact hook script, the exact shell alias — don't just explain the feature and
+  leave wiring up to the reader.
+- **Skip what they already know.** No need to re-explain what the tool is at
+  length — the tagline and one-liner blockquote handle that. Get to the
+  commands.
+- **Prefer concrete over abstract.** Instead of "you can configure X via a
+  config file", show the config file contents.
+
+## Shell Naming Conventions
+
+**Variables:**
+
+- `ALL_CAPS` — environment variables only (`PATH`, `HOME`, `WEBI_VERSION`)
+- `b_varname` — block-scoped (inside a function, loop, or conditional)
+- `g_varname` — global to the script (and sourced scripts)
+- `a_varname` — function arguments
+
+**Functions and commands:**
+
+- `fn_name` — helper functions (anything other than the script's main/entry
+  function)
+- `cmd_name` — command aliases, e.g. `cmd_curl='curl --fail-with-body -sSL'`
+
+## Code Style
+
+Requires `node`, `shfmt`, `pwsh`, and `pwsh-essentials` (install all via webi).
+Run before committing:
+
+```sh
+npm run fmt         # prettier (JS/MD) + shfmt (sh) + pwsh-fmt (ps1)
+npm run lint        # jshint + shellcheck + pwsh-lint
+```
+
+Commit messages: `feat(<pkg>): add installer`, `fix(<pkg>): update install.sh`,
+`docs(<pkg>): add cheat sheet`.
+
+## Naming Conventions
+
+- The canonical package name is the **command name** you type: `go`, `node`,
+  `rg`
+- The alternate/alias name is the project name: `golang`, `nodejs`, `ripgrep`
+- Package directories are lowercase with hyphens
+
+## Common Pitfalls
+
+- **Monorepo releases**: The GitHub API returns ALL releases for the repo. You
+  must filter in `releases.js` and strip the tag prefix from the version.
+- **No `--version` flag**: Some tools lack version introspection. Comment out
+  `pkg_get_current_version` — webi still works, it just can't skip reinstalls.
+- **normalize.js auto-detection**: OS/arch/ext are guessed from download
+  filenames. If the tool uses non-standard naming, you may need to set `os`,
+  `arch`, or `ext` explicitly in `releases.js`.
+- **Goreleaser archives**: Typically contain a bare binary at the archive root
+  (not nested in a directory). Use `mv ./cmd "$pkg_src_cmd"`.

CONTRIBUTING.md

@@ -10,7 +10,6 @@
 
 - You'll be asked to make changes if you don't run the code formatters and
   linters:
-
   - Node / JavaScript:
     - [prettier](https://webinstall.dev/prettier)
       ```sh
@@ -21,7 +20,6 @@
       npm run lint
       ```
   - Bash
-
     - [shfmt](https://webinstall.dev/shfmt)
       ```sh
       npm run shfmt

_example/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading foobar 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing foobar"
 
     # TODO: create package-specific temp directory

_scripts/pwsh-fmt.ps1

@@ -15,8 +15,8 @@ foreach ($my_dir in $my_dirs) {
         $my_ps1 = [System.IO.Path]::GetRelativePath($my_cwd, $my_file.FullName)
         $my_dir = [System.IO.Path]::GetDirectoryName($my_file.FullName)
 
-        if (-Not (Test-Path -PathType Leaf -Path $my_ps1) -or
-            -Not (Test-Path -PathType Container -Path $my_dir)) {
+        if (-not (Test-Path -PathType Leaf -Path $my_ps1) -or
+            -not (Test-Path -PathType Container -Path $my_dir)) {
             Write-Host ("    SKIP {0} (non-regular file or parent directory)" -f $my_ps1)
             continue
         }
@@ -31,7 +31,7 @@ foreach ($my_dir in $my_dirs) {
         $my_new_file | Set-Content -Path $my_ps1
 
         $my_new_file = $my_new_file + "`n"
-        IF ($text -ne $my_new_file) {
+        if ($text -ne $my_new_file) {
             $my_status = 1
         }
     }

_scripts/pwsh-lint.ps1

@@ -15,8 +15,8 @@ foreach ($my_dir in $my_dirs) {
         $my_ps1 = [System.IO.Path]::GetRelativePath($my_cwd, $my_file.FullName)
         $my_dir = [System.IO.Path]::GetDirectoryName($my_file.FullName)
 
-        if (-Not (Test-Path -PathType Leaf -Path $my_ps1) -or
-            -Not (Test-Path -PathType Container -Path $my_dir)) {
+        if (-not (Test-Path -PathType Leaf -Path $my_ps1) -or
+            -not (Test-Path -PathType Container -Path $my_dir)) {
             Write-Host ("    SKIP {0} (non-regular file or parent directory)" -f $my_ps1)
             continue
         }
@@ -39,7 +39,7 @@ foreach ($my_dir in $my_dirs) {
         $my_new_file | Set-Content -Path $my_ps1
 
         $my_new_file = $my_new_file + "`n"
-        IF ($my_old_file -ne $my_new_file) {
+        if ($my_old_file -ne $my_new_file) {
             $my_status = 1
         }
     }

_vim-example/install.ps1

@@ -1,6 +1,6 @@
 #!/usr/bin/env pwsh
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
     New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
 }
 Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\example" -Recurse -ErrorAction Ignore

_webi/builds-cacher.js

@@ -56,14 +56,15 @@ var TERMS_META = [
 /** @typedef {String} VersionString */
 /** @typedef {Object.<VersionString, Array<BuildAsset>>} PackagesByRelease */
 
-/** @typedef {ProjectMeta & ProjectInfoPartial} ProjectInfo */
 /**
- * @typedef ProjectMeta
+ * @typedef ProjectInfo
+ * @prop {Array<BuildAsset>} releases
  * @prop {Array<BuildAsset>} packages
  * @prop {Object.<TripletString, PackagesByRelease>} releasesByTriplet
  * @prop {Array<import('./build-classifier/types.js').ArchString>} arches
  * @prop {Array<import('./build-classifier/types.js').OsString>} oses
  * @prop {Array<import('./build-classifier/types.js').LibcString>} libcs
+ * @prop {Array<String>} channels
  * @prop {Array<String>} formats
  * @prop {Array<String>} triplets
  * @prop {Array<String>} versions
@@ -71,12 +72,6 @@ var TERMS_META = [
  * @prop {Object.<String, String>} lexversMap
  */
 
-/**
- * @typedef ProjectInfoPartial
- * @prop {Array<BuildAsset>} releases
- * @prop {Array<String>} channels
- */
-
 /**
  * @typedef BuildAsset
  * @prop {String} name
@@ -88,8 +83,6 @@ var TERMS_META = [
  * @prop {String} libc
  * @prop {String} ext
  * @prop {String} download
- * @prop {import('./build-classifier/types.js').TargetTriplet} [target]
- * @prop {String} [lexver]
  */
 
 /**
@@ -107,18 +100,6 @@ var TERMS_META = [
  * @prop {Error} target.error
  */
 
-/**
- * @typedef {Error & WebiErrorPartial} WebiError
- * @typedef WebiErrorPartial
- * @prop {String} code
- * @prop {Number} status
- */
-
-/** @typedef {String} PathString */
-
-/**
- * @param {PathString} path
- */
 async function getPartialHeader(path) {
   let readme = `${path}/README.md`;
   let head = await readFirstBytes(readme).catch(function (err) {
@@ -131,9 +112,8 @@ async function getPartialHeader(path) {
   return head;
 }
 
-/**
- * @param {PathString} path
- */
+// let fsOpen = util.promisify(Fs.open);
+// let fsRead = util.promisify(Fs.read);
 async function readFirstBytes(path) {
   let start = 0;
   let n = 1024;
@@ -146,29 +126,15 @@ async function readFirstBytes(path) {
   return str;
 }
 
-/** @type {Object.<String, Promise<void>>} */
 let promises = {};
-
-/**
- * @param {import('../_example/releases.js')?} Releases
- * @param {PathString} installersDir
- * @param {PathString} cacheDir
- * @param {PathString} name
- * @param {Date?} [date]
- */
 async function getLatestBuilds(Releases, installersDir, cacheDir, name, date) {
   console.info(`[INFO] getLatestBuilds: ${name}`);
 
   if (!Releases) {
     Releases = require(`${installersDir}/${name}/releases.js`);
   }
-  if (!Releases) {
-    throw new Error('unreachable: narrowing for type checker');
-  }
-
   // TODO update all releases files with module.exports.xxxx = 'foo';
   if (!Releases.latest) {
-    //@ts-expect-error
     Releases.latest = Releases;
   }
 
@@ -184,12 +150,6 @@ async function getLatestBuilds(Releases, installersDir, cacheDir, name, date) {
   return await promises[id];
 }
 
-/**
- * @param {import('../_example/releases.js')} Releases
- * @param {PathString} cacheDir
- * @param {PathString} name
- * @param {Date?} [date]
- */
 async function getLatestBuildsInner(Releases, cacheDir, name, date) {
   let data = await Releases.latest();
 
@@ -231,14 +191,11 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
   bc.orphanTerms = Object.assign({}, bc.ALL_TERMS);
   bc.unknownTerms = {};
   bc.usedTerms = {};
-  /** @type {Array<String>} */
   bc.formats = [];
   bc._triplets = {};
   bc._targetsByBuildIdCache = {};
-  /** @type {Object.<String, ProjectInfo>} */
   bc._caches = {};
   bc._staleAge = 15 * 60 * 1000;
-  /** @type {Object.<String, Array<String>>} */
   bc._allFormats = {};
   bc._allTriplets = {};
 
@@ -286,8 +243,8 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     let filepath = Path.join(installersDir, name);
     let entry;
     try {
-      let stat = await Fs.lstat(filepath);
-      entry = Object.assign(stat, { name: name });
+      entry = await Fs.lstat(filepath);
+      Object.assign(entry, { name: name });
     } catch (e) {
       return { type: 'errors', detail: 'not found' };
     }
@@ -298,7 +255,7 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
 
   /**
    * Get project type and detail - alias, selfhosted, valid (and the invalids)
-   * @param {Omit<import('fs').Dirent, "path"|"parentPath">} entry
+   * @param {fs.Stats|fs.Dirent} entry
    */
   bc.getProjectTypeByEntry = async function (entry) {
     let path = Path.join(installersDir, entry.name);
@@ -343,9 +300,7 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     let releasesPath = Path.join(path, 'releases.js');
     try {
       void require(releasesPath);
-    } catch (_err) {
-      /** @type {WebiError} */ // @ts-expect-error
-      let err = _err;
+    } catch (err) {
       if (err.code !== 'MODULE_NOT_FOUND') {
         return { type: 'errors', detail: err };
       }
@@ -360,16 +315,9 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     return { type: 'valid', detail: true };
   };
 
-  /**
-   * 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).
-   *
-   * @param {Object} opts
-   * @param {import('../_example/releases.js')?} [opts.Releases]
-   * @param {PathString} opts.name
-   * @param {Date} opts.date
-   */
-  bc.getPackages = async function ({ Releases = null, name, date }) {
+  // 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();
     }
@@ -394,7 +342,6 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
 
     let projInfo = bc._caches[name];
 
-    /** @type {ProjectMeta} */
     let meta = {
       // version info
       versions: projInfo?.versions || [],
@@ -413,23 +360,20 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     };
 
     if (!projInfo) {
-      let NULLSTRING = 'null';
       let json = await Fs.readFile(dataFile, 'ascii').catch(
         async function (err) {
           if (err.code !== 'ENOENT') {
             throw err;
           }
 
-          return NULLSTRING;
+          return null;
         },
       );
 
       try {
         projInfo = JSON.parse(json);
-      } catch (_err) {
-        /** @type {WebiError} */ // @ts-expect-error
-        let err = _err;
-        console.error(`error: ${dataFile}:\n\t${err.message}`);
+      } catch (e) {
+        console.error(`error: ${dataFile}:\n\t${e.message}`);
         projInfo = null;
       }
     }
@@ -454,34 +398,23 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
         return;
       }
 
-      projInfo = await getLatestBuilds(Releases, installersDir, cacheDir, name)
-        .then(function () {
-          let latestProjInfo = BuildsCacher.transformAndUpdate(
-            name,
-            projInfo,
-            meta,
-            date,
-            bc,
-          );
-          bc._caches[name] = latestProjInfo;
-        })
-        .catch(function (err) {
-          console.error(`Fail when fetching latest builds for '${name}'`);
-          console.error(err);
-        });
+      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
-  /** @type {Array<String>} */
   bc._staleNames = [];
-  /** @type {ReturnType<typeof setTimeout>?} */
   bc._freshenTimeout = null;
-  /**
-   * @param {Number?} [minDelay]
-   */
   bc.freshenRandomPackage = async function (minDelay) {
     if (!minDelay) {
       minDelay = 15 * 1000;
@@ -498,7 +431,7 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     let name = bc._staleNames.pop();
     void (await bc.getPackages({
       //Releases: Releases,
-      name: name || '',
+      name: name,
       date: new Date(),
     }));
     console.info(`[INFO] freshenRandomPackage: ${name}`);
@@ -509,9 +442,7 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     let seed = Math.random();
     delay += seed * spread;
 
-    if (bc._freshenTimeout) {
-      clearTimeout(bc._freshenTimeout);
-    }
+    clearTimeout(bc._freshenTimeout);
     bc._freshenTimeout = setTimeout(bc.freshenRandomPackage, delay);
     bc._freshenTimeout.unref();
   };
@@ -534,8 +465,6 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
    *     .tar.xz
    *     .xz
    *     .zip
-   *
-   * @param {Array<String>} formats
    */
   bc.getSortedFormats = function (formats) {
     /* jshint maxcomplexity: 25 */
@@ -644,10 +573,6 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
     return exts;
   };
 
-  /**
-   * @param {Array<BuildAsset>} packages
-   * @param {Array<String>} formats
-   */
   bc.selectPackage = function (packages, formats) {
     if (packages.length === 1) {
       return packages[0];
@@ -836,11 +761,6 @@ BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
   return bc;
 };
 
-/**
- * @param {ReturnType<typeof BuildsCacher.create>} bc
- * @param {ProjectInfo} projInfo
- * @param {BuildAsset} build
- */
 BuildsCacher._classify = function (bc, projInfo, build) {
   /* jshint maxcomplexity: 25 */
   let maybeInstallable = Triplet.maybeInstallable(projInfo, build);
@@ -1021,11 +941,7 @@ BuildsCacher.transformAndUpdate = function (name, projInfo, meta, date, bc) {
 };
 
 // TODO
-//  - tag channels
-/**
- * @param {ProjectInfo} projInfo
- * @param {ProjectMeta} meta
- */
+//   - tag channels
 BuildsCacher.updateAndSortVersions = function (projInfo, meta) {
   for (let build of projInfo.packages) {
     let hasVersion = meta.versions.includes(build.version);
@@ -1045,31 +961,17 @@ BuildsCacher.updateAndSortVersions = function (projInfo, meta) {
     meta.versions.push(version);
   }
 
-  projInfo.packages.sort(BuildsCacher.sortByLexver);
+  projInfo.packages.sort(function (a, b) {
+    if (a.lexver > b.lexver) {
+      return -1;
+    }
+    if (a.lexver < b.lexver) {
+      return 1;
+    }
+    return 0;
+  });
 };
 
-/**
- * @typedef HasLexver
- * @prop {String} lexver
- */
-
-/**
- * @param {HasLexver} a
- * @param {HasLexver} b
- */
-BuildsCacher.sortByLexver = function (a, b) {
-  if (a.lexver > b.lexver) {
-    return -1;
-  }
-  if (a.lexver < b.lexver) {
-    return 1;
-  }
-  return 0;
-};
-
-/**
- * @param {ProjectMeta} meta
- */
 BuildsCacher.updateReleasesByTriplet = function (meta) {
   for (let build of meta.packages) {
     let target = build.target;

_webi/curl-pipe-bootstrap.tpl.ps1

@@ -6,7 +6,12 @@
 ############################################################
 New-Item -Path "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 New-Item -Path "$Env:USERPROFILE\.local\bin" -ItemType Directory -Force | Out-Null
-IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
-curl.exe -s -A "windows" "$Env:WEBI_HOST/packages/webi/webi-pwsh.ps1" -o "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1"
+if ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+$b_webi_ps1 = "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1"
+curl.exe -s -A "windows" "$Env:WEBI_HOST/packages/webi/webi-pwsh.ps1" | Out-File -Encoding utf8 "$b_webi_ps1"
+if ($LASTEXITCODE -ne 0 -or -not (Test-Path "$b_webi_ps1") -or (Get-Item "$b_webi_ps1").Length -lt 100) {
+    Write-Error "error: failed to download '$Env:WEBI_HOST/packages/webi/webi-pwsh.ps1'"
+    exit 1
+}
 Set-ExecutionPolicy -Scope Process Bypass
-& "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" "{{ exename }}"
+& "$b_webi_ps1" "{{ exename }}"

_webi/package-install.tpl.ps1

@@ -45,15 +45,15 @@ $TDim = "${Esc}[2m"
 $TReset = "${Esc}[0m"
 
 function Invoke-DownloadUrl {
-    Param (
+    param (
         [string]$URL,
         [string]$Params,
         [string]$Path,
         [switch]$Force
     )
 
-    IF (Test-Path -Path "$Path") {
-        IF (-Not $Force.IsPresent) {
+    if (Test-Path -Path "$Path") {
+        if (-not $Force.IsPresent) {
             Write-Host "    ${TDim}Found${TReset} $Path"
             return
         }
@@ -65,7 +65,7 @@ function Invoke-DownloadUrl {
 
     Write-Host "    Downloading ${TDim}from${TReset}"
     Write-Host "      ${TDim}${URL}${TReset}"
-    IF ($Params.Length -ne 0) {
+    if ($Params.Length -ne 0) {
         Write-Host "        ?$Params"
         $URL = "${URL}?${Params}"
     }
@@ -80,18 +80,18 @@ function Get-UserAgent {
     # This is the canonical CPU arch when the process is emulated
     $my_arch = "$Env:PROCESSOR_ARCHITEW6432"
 
-    IF ($my_arch -eq $null -or $my_arch -eq "") {
+    if ($my_arch -eq $null -or $my_arch -eq "") {
         # This is the canonical CPU arch when the process is native
         $my_arch = "$Env:PROCESSOR_ARCHITECTURE"
     }
 
-    IF ($my_arch -eq "AMD64") {
+    if ($my_arch -eq "AMD64") {
         # Because PowerShell is sometimes AMD64 on Windows 10 ARM
         # See https://oofhours.com/2020/02/04/powershell-on-windows-10-arm64/
         $my_os_arch = (Get-CimInstance -ClassName Win32_OperatingSystem).OSArchitecture
 
         # Using -clike because of the trailing newline
-        IF ($my_os_arch -clike "ARM 64*") {
+        if ($my_os_arch -clike "ARM 64*") {
             $my_arch = "ARM64"
         }
     }
@@ -124,7 +124,7 @@ function webi_path_add($pathname) {
             $exists_in_path = $true
         }
     }
-    if (-Not $exists_in_path) {
+    if (-not $exists_in_path) {
         $all_user_paths = "${pathname};${all_user_paths}".Trim(';')
         [Environment]::SetEnvironmentVariable("Path", $all_user_paths, "User")
         $null = Sync-EnvPath

aliasman/README.md

@@ -72,8 +72,8 @@ gc "feat: new feature"
 
 ### Common aliases
 
-Use *alias*es to make other tools you find around webi even _more_ convenient
-⚡️ (and powerful 💪).
+Use *alias*es to make other tools you find around webi even _more_ convenient ⚡️
+(and powerful 💪).
 
 ```sh
 aliasman curl 'curlie'

arc/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading archiver 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing archiver"
 
     # TODO: create package-specific temp directory

archiver/install.ps1

@@ -1,5 +1,5 @@
 #!/bin/pwsh
 
 Write-Output "'archiver@$Env:WEBI_TAG' is an alias for 'arc@$Env:WEBI_VERSION'"
-IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+if ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
 curl.exe -A MS -fsSL "$Env:WEBI_HOST/arc@$Env:WEBI_VERSION" | powershell

atomicparsley/install.ps1

@@ -20,7 +20,7 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Checking for (or Installing) MSVC Runtime..."
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
 
@@ -29,7 +29,7 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing AtomicParsley"
 
     # TODO: create package-specific temp directory

awless/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading awless 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing awless"
 
     # TODO: create package-specific temp directory

bat/install.ps1

@@ -3,7 +3,7 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
@@ -11,11 +11,11 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
 
 # Fetch MSVC Runtime
 Write-Output "Checking for MSVC Runtime..."
-IF (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
+if (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

bun/releases.js

@@ -6,15 +6,27 @@ 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) {
-        let isDebug = r.name.includes('-profile');
-        if (isDebug) {
+        if (r.name.includes('-profile')) {
           return false;
         }
 
-        let isAncient = r.name.includes('-baseline');
-        if (isAncient) {
+        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;
         }
 
@@ -22,13 +34,15 @@ module.exports = function () {
         if (isMusl) {
           r._musl = true;
           r.libc = 'musl';
-        } else if (r.os === 'linux') {
+        } 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;

caddy/README.md

@@ -1181,7 +1181,8 @@ To prevent search engine and browser confusion
 - _DO NOT_ prevent crawling via `robots.txt` \
   (counter-intuitive, but pages _must_ be crawled for links to _NOT_ be indexed)
 - _all_ domains using public TLS certs _will_ be indexed by default \
-  (they are all linked to and crawled from various Certificate Transparency reports)
+  (they are all linked to and crawled from various Certificate Transparency
+  reports)
 - follow these guidelines even if the dev sites use HTTP Basic Auth
 
 ```Caddyfile

caddy/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading caddy 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing caddy"
 
     # TODO: create package-specific temp directory

chromedriver/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading chromedriver 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing chromedriver"
 
     # TODO: create package-specific temp directory

cilium/install.ps1

@@ -17,13 +17,13 @@ $pkg_src = "$pkg_src_cmd"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading cilium 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing cilium"
     Push-Location .local\tmp
 

cmake/install.ps1

@@ -20,13 +20,13 @@ 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")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading cmake 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_dir")) {
+if (!(Test-Path -Path "$pkg_src_dir")) {
     Write-Output "Installing cmake"
 
     # TODO: create package-specific temp directory

comrak/install.ps1

@@ -3,13 +3,13 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

crabz/install.ps1

@@ -20,13 +20,13 @@ 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")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading crabz 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing crabz"
 
     # TODO: create package-specific temp directory

curlie/install.ps1

@@ -3,13 +3,13 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

dashcore/README.md

@@ -147,8 +147,8 @@ dash-qt \
 CoinJoin aids in preventing some bad actors and malicious observers being able
 to easily reconstruct details about your transactions from the publicly
 available data by creating many excess transactions. \
-(be aware, however, that dedicated bad actors can use sophisticated software that
-will reveal much of the same information over time)
+(be aware, however, that dedicated bad actors can use sophisticated software
+that will reveal much of the same information over time)
 
 `dash-qt` does not enable CoinJoin mixing by default.
 

dashcore/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading dashcore 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_dir")) {
+if (!(Test-Path -Path "$pkg_src_dir")) {
     Write-Output "Installing dashcore"
 
     # TODO: create package-specific temp directory

dashd/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading dashd 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_dir")) {
+if (!(Test-Path -Path "$pkg_src_dir")) {
     Write-Output "Installing dashd"
 
     # TODO: create package-specific temp directory

dashmsg/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading dashmsg 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing dashmsg"
 
     # TODO: create package-specific temp directory

delta/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading delta 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing delta"
 
     # TODO: create package-specific temp directory

deno/install.ps1

@@ -1,14 +1,14 @@
 #!/usr/bin/env pwsh
 
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     #Invoke-WebRequest https://nodejs.org/dist/v12.16.2/node-v12.16.2-win-x64.zip -OutFile node-v12.16.2-win-x64.zip
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

dotenv-linter/install.ps1

@@ -20,18 +20,18 @@ $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 # Fetch MSVC Runtime
 Write-Output "Checking for MSVC Runtime..."
-IF (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
+if (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading dotenv-linter 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing dotenv-linter"
 
     # TODO: create package-specific temp directory

dotenv/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading dotenv 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing dotenv"
 
     # TODO: create package-specific temp directory

fd/install.ps1

@@ -3,13 +3,13 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

ffmpeg/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading ffmpeg 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 -Path "$pkg_download.part" -Destination "$pkg_download" -Force
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing ffmpeg"
 
     # TODO: create package-specific temp directory

ffuf/install.ps1

@@ -20,13 +20,13 @@ New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-IF (-Not (Test-Path -Path "$pkg_download")) {
+if (-not (Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading ffuf 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 (-Not (Test-Path -Path "$pkg_src_cmd")) {
+if (-not (Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing ffuf"
 
     # TODO: create package-specific temp directory

fzf/install.ps1

@@ -3,13 +3,13 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

gh/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading gh 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing gh"
 
     # TODO: create package-specific temp directory

git-gpg-init/install.ps1

@@ -1,5 +1,5 @@
 #!/bin/pwsh
 
 Write-Output "'git-gpg-init@$Env:WEBI_TAG' is an alias for 'git-config-gpg@$Env:WEBI_VERSION'"
-IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+if ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
 curl.exe -A MS -fsSL "$Env:WEBI_HOST/git-config-gpg@$Env:WEBI_VERSION" | powershell

git/install.ps1

@@ -11,13 +11,13 @@ $pkg_dst_cmd = "$pkg_dst\cmd\$pkg_cmd_name"
 $pkg_dst_bin = "$pkg_dst\cmd"
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading $Env:PKG_NAME 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")) {
+if (!(Test-Path -Path "$pkg_src")) {
     Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
@@ -30,12 +30,12 @@ IF (!(Test-Path -Path "$pkg_src")) {
     # Unpack archive
     # Windows BSD-tar handles zip. Imagine that.
     Write-Output "Unpacking $pkg_download"
-    IF (!(Test-Path -Path "$pkg_cmd_name-v$Env:WEBI_VERSION")) {
+    if (!(Test-Path -Path "$pkg_cmd_name-v$Env:WEBI_VERSION")) {
         New-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -ItemType Directory -Force | Out-Null
     }
-        ($none = Push-Location "$pkg_cmd_name-v$Env:WEBI_VERSION")  | Out-Null
+    ($none = Push-Location "$pkg_cmd_name-v$Env:WEBI_VERSION")  | Out-Null
     & tar xf "$pkg_download"
-        ($none = Pop-Location)  | Out-Null
+    ($none = Pop-Location)  | Out-Null
 
     # Settle unpacked archive into place
     Write-Output "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"

gitdeploy/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading gitdeploy 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing gitdeploy"
 
     # TODO: create package-specific temp directory

gitea/install.ps1

@@ -19,19 +19,19 @@ New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 Write-Output "Checking for Git..."
-IF (-Not (Get-Command -Name "git" -ErrorAction Silent)) {
+if (-not (Get-Command -Name "git" -ErrorAction Silent)) {
     & "$HOME\.local\bin\webi-pwsh.ps1" git
     $null = Sync-EnvPath
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading gitea 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing gitea"
 
     # TODO: create package-specific temp directory

go/install.ps1

@@ -16,13 +16,13 @@ if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading $Env:PKG_NAME 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")) {
+if (!(Test-Path -Path "$pkg_src")) {
     Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
@@ -50,7 +50,7 @@ IF (!(Test-Path -Path "$pkg_src")) {
 Write-Output "Copying into '$pkg_dst' from '$pkg_src'"
 Remove-Item -Path "$pkg_dst" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
-IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
+if (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
 
 # Add to path
 webi_path_add ~/.local/opt/go/bin

golang/install.ps1

@@ -16,13 +16,13 @@ if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading $Env:PKG_NAME 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")) {
+if (!(Test-Path -Path "$pkg_src")) {
     Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
@@ -50,7 +50,7 @@ IF (!(Test-Path -Path "$pkg_src")) {
 Write-Output "Copying into '$pkg_dst' from '$pkg_src'"
 Remove-Item -Path "$pkg_dst" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
-IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
+if (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
 
 # Add to path
 webi_path_add ~/.local/opt/go/bin

goreleaser/README.md

@@ -122,8 +122,8 @@ goreleaser --clean
 
 Check the console output to make sure that there are no messages about a failed
 publish. \
-If all is well you should the git tag on the releases page updated with a ChangeLog
-and the published binaries.
+If all is well you should see the git tag on the releases page updated with a
+ChangeLog and the published binaries.
 
 ### How to Publish to Gitea and others
 

goreleaser/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading goreleaser 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing goreleaser"
 
     # TODO: create package-specific temp directory

gpg-pubkey/install.ps1

@@ -3,7 +3,7 @@
 $ErrorActionPreference = 'stop'
 
 function Install-WebiHostedScript () {
-    Param(
+    param(
         [string]$Package,
         [string]$ScriptName
     )
@@ -31,15 +31,15 @@ Install-WebiHostedScript -Package "gpg-pubkey" -ScriptName "gpg-pubkey"
 #
 # Check the gpg exists
 #
-IF (-Not (Get-Command -Name "gpg" -ErrorAction SilentlyContinue)) {
+if (-not (Get-Command -Name "gpg" -ErrorAction SilentlyContinue)) {
     & "${Env:USERPROFILE}\.local\bin\webi-pwsh.ps1" gpg
     $Env:Path = [Environment]::GetEnvironmentVariable("Path", "User")
 
-    IF (-Not (Get-Command -Name "gpg" -ErrorAction SilentlyContinue)) {
+    if (-not (Get-Command -Name "gpg" -ErrorAction SilentlyContinue)) {
         Write-Output ""
         Write-Output "(exited because gpg is not installed)"
         Write-Output ""
-        Exit 1
+        exit 1
     }
 }
 

gprox/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading gprox 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing gprox"
 
     # TODO: create package-specific temp directory

grype/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading grype 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing grype"
 
     # TODO: create package-specific temp directory

hugo-extended/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading hugo-extended 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing hugo-extended"
 
     # TODO: create package-specific temp directory

hugo/install.ps1

@@ -20,13 +20,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading hugo 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing hugo"
 
     # TODO: create package-specific temp directory

jq/install.ps1

@@ -3,13 +3,13 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\bin\$VERNAME")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

julia/install.ps1

@@ -20,13 +20,13 @@ 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")) {
+if (!(Test-Path -Path "$pkg_download")) {
     Write-Output "Downloading julia 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_dir")) {
+if (!(Test-Path -Path "$pkg_src_dir")) {
     Write-Output "Installing julia"
 
     # TODO: create package-specific temp directory

k9s/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading k9s 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing k9s"
 
     # TODO: create package-specific temp directory

keypairs/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading keypairs 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing keypairs"
 
     # TODO: create package-specific temp directory

kind/install.ps1

@@ -17,13 +17,13 @@ $pkg_src = "$pkg_src_cmd"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading kind 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing kind"
     Push-Location .local\tmp
 

kubectx/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading kubectx 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing kubectx"
 
     # TODO: create package-specific temp directory

kubens/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading kubens 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing kubens"
 
     # TODO: create package-specific temp directory

lf/install.ps1

@@ -17,13 +17,13 @@ $pkg_src = "$pkg_src_cmd"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading lf 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing lf"
 
     Push-Location .local\tmp

lsd/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading lsd 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing lsd"
 
     # TODO: create package-specific temp directory

monorel/README.md

@@ -0,0 +1,165 @@
+---
+title: monorel
+homepage: https://github.com/therootcompany/golib/tree/main/tools/monorel
+tagline: |
+  monorel: Monorepo Release Tool for Go binaries.
+---
+
+To update or switch versions, run `webi monorel@stable` (or `@v0.6`, `@beta`,
+etc).
+
+### Files
+
+These are the files that are created and/or modified with this installer:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/monorel
+~/.local/opt/monorel-VERSION/bin/monorel
+```
+
+These are the files that monorel creates and/or modifies in your project:
+
+```text
+<module>/.goreleaser.yaml
+.git/refs/tags/<module>/v*
+```
+
+## Cheat Sheet
+
+> `monorel` manages independently-versioned Go modules and releases in a single
+> repository — initializing goreleaser configs, bumping versions, and publishing
+> multi-arch releases.
+
+### How to use monorel
+
+```sh
+# Generate .goreleaser.yaml for all modules
+monorel init --recursive ./
+
+# Tag the next patch version for all modules with new commits
+monorel bump --recursive ./
+
+# Build, package, and publish GitHub releases for all binaries of a module
+monorel release --recursive ./tools/monorel
+```
+
+### How monorepo versioning works
+
+Each `go.mod` is an independently-versioned module. Tags use the module's path
+as a prefix, and each module with binaries gets a `.goreleaser.yaml`:
+
+```text
+./
+├── go.mod                          # v0.1.1 (library-only)
+├── io/
+│   └── transform/
+│       └── gsheet2csv/
+│           ├── go.mod              # io/transform/gsheet2csv/v1.0.5
+│           ├── .goreleaser.yaml
+│           └── cmd/
+│               ├── gsheet2csv/
+│               ├── gsheet2env/
+│               └── gsheet2tsv/
+└── tools/
+    └── monorel/
+        ├── go.mod                  # tools/monorel/v1.0.0
+        └── .goreleaser.yaml
+```
+
+### `monorel init` vs `goreleaser init`
+
+`goreleaser init` generates a config that assumes one module per repo and
+derives names and versions from the git tag. That breaks in a monorepo with
+prefixed tags. `monorel init` fixes this:
+
+|               | `goreleaser init`           | `monorel init`                          |
+| ------------- | --------------------------- | --------------------------------------- |
+| Project name  | `{{ .ProjectName }}`        | Hard-coded binary name                  |
+| Version       | Derived from git tag        | `{{ .Env.VERSION }}` (plain semver)     |
+| Publishing    | goreleaser's built-in       | Disabled; uses `gh release` instead     |
+| Multiple bins | Manual config               | Auto-discovered, shared via YAML anchor |
+| Monorepo tags | (requires Pro subscription) | Prefix-aware (`cmd/foo/v1.2.3`)         |
+
+### Generated `.goreleaser.yaml`: single binary
+
+For a module with one binary (like `tools/monorel/`), the generated config has a
+single build entry:
+
+```yaml
+builds:
+  - id: monorel
+    binary: monorel
+    env:
+      - CGO_ENABLED=0
+    ldflags:
+      - >-
+        -s -w -X main.version={{.Env.VERSION}} -X main.commit={{.Commit}} -X
+        main.date={{.Date}}
+    goos:
+      - darwin
+      - linux
+      - windows
+      # ... and more
+
+archives:
+  - id: monorel
+    ids: [monorel]
+    # Hard-coded name instead of {{ .ProjectName }} — goreleaser derives
+    # ProjectName from the prefixed tag, which would produce messy filenames.
+    # {{ .Env.VERSION }} for the same reason — the raw tag version includes
+    # the module path prefix.
+    name_template: >-
+      monorel_{{ .Env.VERSION }}_{{ title .Os }}_{{ .Arch }}
+
+# goreleaser Pro would be needed to publish from a prefixed tag,
+# so monorel disables goreleaser's publisher and uses 'gh release' instead.
+release:
+  disable: true
+```
+
+### Generated `.goreleaser.yaml`: multiple binaries
+
+When a module has several commands under `cmd/`, monorel generates a build entry
+per binary with shared settings via a YAML anchor:
+
+```yaml
+builds:
+  - id: gsheet2csv
+    binary: gsheet2csv
+    main: ./cmd/gsheet2csv
+    <<: &build_defaults
+      env:
+        - CGO_ENABLED=0
+      ldflags:
+        - >-
+          -s -w -X main.version={{.Env.VERSION}}
+      goos:
+        - darwin
+        - linux
+        - windows
+        # ...
+  - id: gsheet2env
+    binary: gsheet2env
+    main: ./cmd/gsheet2env
+    <<: *build_defaults
+  - id: gsheet2tsv
+    binary: gsheet2tsv
+    main: ./cmd/gsheet2tsv
+    <<: *build_defaults
+
+archives:
+  - id: gsheet2csv
+    # All binaries are bundled into one archive per platform.
+    ids: [gsheet2csv, gsheet2env, gsheet2tsv]
+    # Same hard-coded name and {{ .Env.VERSION }} to avoid prefixed tag leaking.
+    name_template: >-
+      gsheet2csv_{{ .Env.VERSION }}_{{ title .Os }}_{{ .Arch }}
+
+# Same as single binary — disable goreleaser's publisher for monorepo tags.
+release:
+  disable: true
+```
+
+All three binaries share one version tag (`io/transform/gsheet2csv/v1.0.5`) and
+one GitHub release.

monorel/install.ps1

@@ -0,0 +1,48 @@
+#!/usr/bin/env pwsh
+
+$pkg_cmd_name = "monorel"
+
+$pkg_dst_cmd = "$Env:USERPROFILE\.local\bin\monorel.exe"
+$pkg_dst = "$pkg_dst_cmd"
+
+$pkg_src_cmd = "$Env:USERPROFILE\.local\opt\monorel-v$Env:WEBI_VERSION\bin\monorel.exe"
+$pkg_src_bin = "$Env:USERPROFILE\.local\opt\monorel-v$Env:WEBI_VERSION\bin"
+$pkg_src_dir = "$Env:USERPROFILE\.local\opt\monorel-v$Env:WEBI_VERSION"
+$pkg_src = "$pkg_src_cmd"
+
+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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading monorel 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 monorel"
+
+    # Enter tmp
+    Push-Location .local\tmp
+
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\monorel-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\monorel.exe" -Recurse -ErrorAction Ignore
+
+    # Unpack archive
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
+
+    # Settle unpacked archive into place
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
+    Move-Item -Path ".\monorel.exe" -Destination "$pkg_src_bin"
+
+    # Exit tmp
+    Pop-Location
+}
+
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
+Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

monorel/install.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+# shellcheck disable=SC2034
+
+set -e
+set -u
+
+__init_monorel() {
+    pkg_cmd_name="monorel"
+
+    pkg_src_dir="$HOME/.local/opt/monorel-v$WEBI_VERSION"
+    pkg_src_cmd="$pkg_src_dir/bin/monorel"
+    pkg_src="$pkg_src_cmd"
+
+    pkg_dst_cmd="$HOME/.local/bin/monorel"
+    pkg_dst="$pkg_dst_cmd"
+
+    # pkg_install must be defined by every package
+    pkg_install() {
+        # ~/.local/opt/monorel-v0.6.5/bin
+        mkdir -p "$(dirname "$pkg_src_cmd")"
+
+        # mv monorel ~/.local/opt/monorel-v0.6.5/bin/monorel
+        mv ./monorel "$pkg_src_cmd"
+    }
+
+    pkg_post_install() {
+        b_old_path="${PATH}"
+        export PATH="$HOME/.local/bin:${PATH}"
+
+        if ! command -v git > /dev/null; then
+            "$HOME/.local/bin/webi" git
+        fi
+
+        if ! command -v gh > /dev/null; then
+            "$HOME/.local/bin/webi" gh
+        fi
+
+        if ! command -v goreleaser > /dev/null; then
+            "$HOME/.local/bin/webi" goreleaser
+        fi
+
+        export PATH="${b_old_path}"
+    }
+
+    pkg_get_current_version() {
+        # 'monorel --version' has output in this format:
+        #       monorel v0.6.6 ba674a6 (2026-03-08T23:24:03Z)
+        # This trims it down to just the version number:
+        #       0.6.6
+        monorel --version 2> /dev/null |
+            head -n 1 |
+            cut -d' ' -f2 |
+            cut -c 2-
+    }
+}
+
+__init_monorel

monorel/releases.js

@@ -0,0 +1,37 @@
+'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/install.ps1

@@ -17,13 +17,13 @@ $pkg_src = "$pkg_src_cmd"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading mutagen 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing mutagen"
 
     Push-Location .local\tmp

myip/install.ps1

@@ -3,7 +3,7 @@
 $ErrorActionPreference = 'stop'
 
 function Install-WebiHostedScript () {
-    Param(
+    param(
         [string]$Package,
         [string]$ScriptName
     )

myip/myip.ps1

@@ -2,12 +2,12 @@
 
 $ipv4 = curl.exe -sf https://api.ipify.org
 
-IF (!($null -eq $ipv4 -or $ipv4 -eq "")) {
+if (!($null -eq $ipv4 -or $ipv4 -eq "")) {
     Write-Output "IPv4 (A)   : $ipv4"
 }
 
 $ipv6 = curl.exe -sf https://api6.ipify.org
 
-IF (!($null -eq $ipv6 -or $ipv6 -eq "")) {
+if (!($null -eq $ipv6 -or $ipv6 -eq "")) {
     Write-Output "IPv6 (AAAA): $ipv6"
 }

nerdfont/install.ps1

@@ -4,7 +4,7 @@ $my_nerdfont_otf = "Droid Sans Mono for Powerline Nerd Font Complete Windows Com
 $my_fontdir = "$Env:UserProfile\AppData\Local\Microsoft\Windows\Fonts"
 
 New-Item -Path "$my_fontdir" -ItemType Directory -Force | Out-Null
-IF (!(Test-Path -Path "$my_fontdir\$my_nerdfont_otf")) {
+if (!(Test-Path -Path "$my_fontdir\$my_nerdfont_otf")) {
     & curl.exe -fsSLo "$my_nerdfont_otf" 'https://github.com/ryanoasis/nerd-fonts/raw/v2.3.3/patched-fonts/DroidSansMono/complete/Droid%20Sans%20Mono%20Nerd%20Font%20Complete%20Windows%20Compatible.otf'
     & Move-Item "$my_nerdfont_otf" "$my_fontdir"
 }

node/README.md

@@ -63,10 +63,11 @@ To run them manually on your code;
 - jshintrc (lint)
   ```sh
   touch .jshintrc .jshintignore
-  jhint -c ./.jshintrc *.js */*.js
+  jshint -c ./.jshintrc *.js */*.js
   ```
 - fixjson \
-  (turns JavaScript Objects with comments, trailing commas, etc into actual json)
+  (turns JavaScript Objects with comments, trailing commas, etc into actual
+  json)
   ```sh
   fixjson -i 2 -w ./package.json
   ```
@@ -234,7 +235,6 @@ Node app as a Non-System (Unprivileged) Service on Mac, Windows, and Linux:
    ```
 
 3. Manage the service
-
    - On macOS
 
      ```sh

node/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     New-Item -Path "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
     #Invoke-WebRequest https://nodejs.org/dist/v12.16.2/node-v12.16.2-win-x64.zip -OutFile node-v12.16.2-win-x64.zip
@@ -9,7 +9,7 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
     Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 

ollama/install.ps1

@@ -21,14 +21,14 @@ $pkg_download_dir = "$Env:USERPROFILE\Downloads\webi\$pkg_cmd_name\$Env:WEBI_VER
 $pkg_download_file = "$pkg_download_dir\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download_file")) {
+if (!(Test-Path -Path "$pkg_download_file")) {
     New-Item "$pkg_download_dir" -ItemType Directory -Force | Out-Null
     Write-Output "    Downloading $pkg_cmd_name v$Env:WEBI_VERSION from $Env:WEBI_PKG_URL to $pkg_download_file"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download_file.part"
     & Move-Item "$pkg_download_file.part" "$pkg_download_file"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "    Installing ollama v$Env:WEBI_VERSION"
 
     # Remove any leftover tmp cruft, recreate location, push into it

ots/install.ps1

@@ -18,13 +18,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading ots 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing ots"
 
     Push-Location .local\tmp

pandoc/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading pandoc 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing pandoc"
 
     # TODO: create package-specific temp directory

pathman/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading pathman 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing pathman"
 
     # TODO: create package-specific temp directory

prettier/install.ps1

@@ -33,7 +33,7 @@ function mktemp-d-t() {
 function npm-install-global($pkgname) {
     # Fetch npm package manager
     Write-Output "Checking for npm..."
-    if (-Not (command-v-silent("npm"))) {
+    if (-not (command-v-silent("npm"))) {
         & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" node
     }
 

psscriptanalyzer/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
 function Repair-MissingCommand {
-    Param(
+    param(
         [string]$Name,
         [string]$Package,
         [string]$Command
@@ -9,15 +9,15 @@ function Repair-MissingCommand {
 
     Write-Host "    Checking for $Name ..."
     $HasCommand = Get-Command -Name $Command -ErrorAction Silent
-    IF ($HasCommand) {
-        Return
+    if ($HasCommand) {
+        return
     }
 
     & "$HOME\.local\bin\webi-pwsh.ps1" $Package
     $null = Sync-EnvPath
 }
 
-IF ($null -eq $Env:WEBI_HOST -or "" -eq $Env:WEBI_HOST) {
+if ($null -eq $Env:WEBI_HOST -or "" -eq $Env:WEBI_HOST) {
     $Env:WEBI_HOST = "https://webinstall.dev"
 }
 
@@ -26,7 +26,7 @@ function Install-PSScriptAnalyzer {
     Repair-MissingCommand -Name "PowerShell Core" -Package "pwsh" -Command "pwsh"
 
     $NeedsTrust = pwsh -Command "Get-PSRepository -Name 'PSGallery' | Where-Object -Property InstallationPolicy -eq 'Untrusted'"
-    IF ($NeedsTrust) {
+    if ($NeedsTrust) {
         Write-Host "    Trusting PSRepository 'PSGallery' ..."
         pwsh -Command "Set-PSRepository -Name 'PSGallery' -InstallationPolicy Trusted"
     }

pwsh-essentials/install.ps1

@@ -3,7 +3,7 @@
 $PkgName = "pwsh-essentials"
 
 function Repair-MissingCommand {
-    Param(
+    param(
         [string]$Name,
         [string]$Package,
         [string]$Command
@@ -11,8 +11,8 @@ function Repair-MissingCommand {
 
     Write-Host "    Checking for $Name ..."
     $HasCommand = Get-Command -Name $Command -ErrorAction Silent
-    IF ($HasCommand) {
-        Return
+    if ($HasCommand) {
+        return
     }
 
     & "$HOME\.local\bin\webi-pwsh.ps1" $Package
@@ -20,7 +20,7 @@ function Repair-MissingCommand {
 }
 
 function Install-WebiHostedPSCoreScript () {
-    Param(
+    param(
         [string]$Package,
         [string]$ScriptName
     )

pwsh-essentials/pwsh-fix.ps1

@@ -22,12 +22,12 @@ function Repair-All($Root) {
         $Style = $Dim
 
         $WasDirty = Repair-File -Filepath $Child
-        IF ($WasDirty) {
+        if ($WasDirty) {
             $WereDirty = $true
             $Style = $Bold
         }
         $RelPath = [System.IO.Path]::GetRelativePath($Root, $Child)
-        IF (Test-Path -PathType Leaf -Path $Root) {
+        if (Test-Path -PathType Leaf -Path $Root) {
             $RelPath = $Root
         }
         Write-Host "    ${Style}${RelPath}${ResetWeight}"
@@ -37,7 +37,7 @@ function Repair-All($Root) {
 }
 
 function Repair-File {
-    Param (
+    param (
         [string]$Filepath
     )
     $WasDirty = $false
@@ -48,7 +48,7 @@ function Repair-File {
     $Fixed = Get-Content -Path $Filepath -Raw
     $Formatted = Invoke-Formatter -ScriptDefinition $Fixed
 
-    IF ($Original -eq $Formatted) {
+    if ($Original -eq $Formatted) {
         $WasDirty = $false
         return $WasDirty
     }
@@ -65,7 +65,7 @@ function Repair-File {
 
 function Repair-Recursively($Paths) {
     $Dirty = $false
-    IF ($Paths.Length -lt 1) {
+    if ($Paths.Length -lt 1) {
         $Paths = , (Get-Location)
     }
 
@@ -73,14 +73,14 @@ function Repair-Recursively($Paths) {
         Write-Host "Fixing ${Root}"
         $Entry = Get-Item $Root
 
-        IF (-Not ((Test-Path -PathType Container -Path $Entry) -Or (Test-Path -PathType Leaf -Path $Entry))) {
+        if (-not ((Test-Path -PathType Container -Path $Entry) -or (Test-Path -PathType Leaf -Path $Entry))) {
             $RelPath = [System.IO.Path]::GetRelativePath($Root, $Entry.FullName)
             Write-Host "    ${Warn}SKIP${ResetColor} ${RelPath} (${Warn}not a regular file or directory${ResetColor})"
             exit 1
         }
 
         $WereDirty = Repair-All $Root $Entry
-        IF ($WereDirty) {
+        if ($WereDirty) {
             $Dirty = $true
         }
     }

pwsh-essentials/pwsh-fmt.ps1

@@ -22,12 +22,12 @@ function Format-All($Root) {
         $Style = $Dim
 
         $WasDirty = Format-File -Filepath $Child
-        IF ($WasDirty) {
+        if ($WasDirty) {
             $WereDirty = $true
             $Style = $Bold
         }
         $RelPath = [System.IO.Path]::GetRelativePath($Root, $Child)
-        IF (Test-Path -PathType Leaf -Path $Root) {
+        if (Test-Path -PathType Leaf -Path $Root) {
             $RelPath = $Root
         }
         Write-Host "    ${Style}${RelPath}${ResetWeight}"
@@ -37,7 +37,7 @@ function Format-All($Root) {
 }
 
 function Format-File {
-    Param (
+    param (
         [string]$Filepath
     )
     $WasDirty = $false
@@ -45,7 +45,7 @@ function Format-File {
     $Original = Get-Content -Path $Filepath -Raw
     $Formatted = Invoke-Formatter -ScriptDefinition $Original
 
-    IF ($Original -eq $Formatted) {
+    if ($Original -eq $Formatted) {
         $WasDirty = $false
         return $WasDirty
     }
@@ -62,7 +62,7 @@ function Format-File {
 
 function Format-Recursively($Paths) {
     $Dirty = $false
-    IF ($Paths.Length -lt 1) {
+    if ($Paths.Length -lt 1) {
         $Paths = , (Get-Location)
     }
 
@@ -70,14 +70,14 @@ function Format-Recursively($Paths) {
         Write-Host "Formatting ${Root}"
         $Entry = Get-Item $Root
 
-        IF (-Not ((Test-Path -PathType Container -Path $Entry) -Or (Test-Path -PathType Leaf -Path $Entry))) {
+        if (-not ((Test-Path -PathType Container -Path $Entry) -or (Test-Path -PathType Leaf -Path $Entry))) {
             $RelPath = [System.IO.Path]::GetRelativePath($Root, $Entry.FullName)
             Write-Host "    ${Warn}SKIP${ResetColor} ${RelPath} (${Warn}not a regular file or directory${ResetColor})"
             exit 1
         }
 
         $WereDirty = Format-All $Root $Entry
-        IF ($WereDirty) {
+        if ($WereDirty) {
             $Dirty = $true
         }
     }

pwsh-essentials/pwsh-lint.ps1

@@ -23,16 +23,16 @@ function Debug-All($Root) {
 
 
         $Diags = Invoke-ScriptAnalyzer -Fix -Path $Child -ExcludeRule PSAvoidUsingWriteHost
-        IF ($Diags.Length -gt 0) {
+        if ($Diags.Length -gt 0) {
             $AreDirty = $true
             $Style = $Bold
         }
         $RelPath = [System.IO.Path]::GetRelativePath($Root, $Child)
-        IF (Test-Path -PathType Leaf -Path $Root) {
+        if (Test-Path -PathType Leaf -Path $Root) {
             $RelPath = $Root
         }
         Write-Host "    ${Style}${RelPath}${ResetWeight}"
-        IF ($Diags.Length -gt 0) {
+        if ($Diags.Length -gt 0) {
             Write-Host ($Diags | Format-List | Out-String)
         }
     }
@@ -42,7 +42,7 @@ function Debug-All($Root) {
 
 function Debug-Recursively($Paths) {
     $Dirty = $false
-    IF ($Paths.Length -lt 1) {
+    if ($Paths.Length -lt 1) {
         $Paths = , (Get-Location)
     }
 
@@ -50,14 +50,14 @@ function Debug-Recursively($Paths) {
         Write-Host "Linting ${Root}"
         $Entry = Get-Item $Root
 
-        IF (-Not ((Test-Path -PathType Container -Path $Entry) -Or (Test-Path -PathType Leaf -Path $Entry))) {
+        if (-not ((Test-Path -PathType Container -Path $Entry) -or (Test-Path -PathType Leaf -Path $Entry))) {
             $RelPath = [System.IO.Path]::GetRelativePath($Root, $Entry.FullName)
             Write-Host "    ${Warn}SKIP${ResetColor} ${RelPath} (${Warn}not a regular file or directory${ResetColor})"
             exit 1
         }
 
         $AreDirty = Debug-All $Root $Entry
-        IF ($AreDirty) {
+        if ($AreDirty) {
             $Dirty = $true
         }
     }

pwsh/install.ps1

@@ -22,7 +22,7 @@ $pkg_download = "$HOME\Downloads\webi\$Env:WEBI_PKG_FILE"
 # Fetch archive
 Invoke-DownloadURL -URL $Env:WEBI_PKG_URL -Path $pkg_download
 
-IF (!(Test-Path -Path "$pkg_src_cmd")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Push-Location "$HOME\.local\tmp"
 
     # Remove any leftover tmp cruft

rclone/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading rclone 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing rclone"
 
     # TODO: create package-specific temp directory

redis-commander/install.ps1

@@ -33,7 +33,7 @@ function mktemp-d-t() {
 function npm-install-global($pkgname) {
     # Fetch npm package manager
     Write-Output "Checking for npm..."
-    if (-Not (command-v-silent("npm"))) {
+    if (-not (command-v-silent("npm"))) {
         & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" node
     }
 

rg/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading ripgrep 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing ripgrep"
 
     # TODO: create package-specific temp directory

ripgrep/install.ps1

@@ -1,3 +1,3 @@
 Write-Output "'ripgrep@$Env:WEBI_TAG' is an alias for 'rg@$Env:WEBI_VERSION'"
-IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+if ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
 curl.exe -A MS -fsSL "$Env:WEBI_HOST/rg@$Env:WEBI_VERSION" | powershell

runzip/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading runzip 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing runzip"
 
     # TODO: create package-specific temp directory

sass/install.ps1

@@ -20,13 +20,13 @@ $pkg_src = "$pkg_src_dir"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading sass (dart-sass) 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing sass (dart-sass)"
 
     Push-Location .local\tmp

sclient/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading sclient 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing sclient"
 
     # TODO: create package-specific temp directory

sd/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading sd 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing sd"
 
     # TODO: create package-specific temp directory

serviceman/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading serviceman 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing serviceman"
 
     # TODO: create package-specific temp directory

shellcheck/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading shellcheck 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing shellcheck"
 
     # TODO: create package-specific temp directory

shfmt/install.ps1

@@ -17,13 +17,13 @@ $pkg_src = "$pkg_src_cmd"
 New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading shfmt 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing shfmt"
 
     # TODO: create package-specific temp directory

sqlc/install.ps1

@@ -20,14 +20,14 @@ $pkg_download_dir = "$Env:USERPROFILE\Downloads\webi\$pkg_cmd_name\$Env:WEBI_VER
 $pkg_download_file = "$pkg_download_dir\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download_file")) {
+if (!(Test-Path -Path "$pkg_download_file")) {
     New-Item "$pkg_download_dir" -ItemType Directory -Force | Out-Null
     Write-Output "    Downloading $pkg_cmd_name v$Env:WEBI_VERSION from $Env:WEBI_PKG_URL to $pkg_download_file"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download_file.part"
     & Move-Item "$pkg_download_file.part" "$pkg_download_file"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "    Installing sqlc v$Env:WEBI_VERSION"
 
     # Remove any leftover tmp cruft and recreate the unpack

sqlpkg/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading sqlpkg 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing sqlpkg"
 
     # TODO: create package-specific temp directory

ssh-authorize/README.md

@@ -81,6 +81,7 @@ This just adds a layer of convenience, and a few benefits:
 
 - handles arbitrary files and URLs, failing bad key lines
 - sets permissions correctly, even if they were incorrect \
-  (which almost no one will to do successfully by hand on Windows on the first try)
+  (which almost no one will be able to do successfully by hand on Windows on the first
+  try)
 - works `curl` (macOS, Ubuntu) or `wget` (Docker, Alpine)
 - enforces `https`

ssh-authorize/install.ps1

@@ -3,7 +3,7 @@
 $ErrorActionPreference = 'stop'
 
 function Install-WebiHostedScript () {
-    Param(
+    param(
         [string]$Package,
         [string]$ScriptName
     )

ssh-authorize/ssh-authorize.ps1

@@ -24,7 +24,7 @@ function Repair-AdminAuthorizedKeyPermission {
         /t /grant "${Env:UserName}:(F)"
 
     # Create whitelist for 'sudoer' authorized keys
-    IF (-Not (Test-Path -Path $AdminAuthorizedKeys)) {
+    if (-not (Test-Path -Path $AdminAuthorizedKeys)) {
         $null = New-Item -Path $AdminAuthorizedKeys -Type 'File'
     }
 
@@ -70,7 +70,7 @@ function Repair-UserAuthorizedKeyPermission {
     $null = New-Item -Type Directory -Force -Path "$HOME\.ssh\"
 
     # touch ~/.ssh/authorized_keys
-    IF (-Not (Test-Path -Path "$HOME\.ssh\authorized_keys")) {
+    if (-not (Test-Path -Path "$HOME\.ssh\authorized_keys")) {
         $null = New-Item -Type 'File' -Path "$HOME\.ssh\authorized_keys"
     }
 
@@ -96,34 +96,34 @@ function Repair-AuthorizedKeyFile($Path) {
     $null = New-Item -Type 'File' -Force -Path $FixedPath
     foreach ($Line in [System.IO.File]::ReadLines($Path)) {
         $Line = $Line.Trim()
-        IF ($Line.Length -eq 0) {
+        if ($Line.Length -eq 0) {
             $null = Add-Content -Path $FixedPath -Value $Line
             continue
         }
-        IF ($Line.StartsWith('#')) {
+        if ($Line.StartsWith('#')) {
             $null = Add-Content -Path $FixedPath -Value $Line
             continue
         }
-        IF ($Line.StartsWith('ssh-')) {
+        if ($Line.StartsWith('ssh-')) {
             $null = Add-Content -Path $FixedPath -Value $Line
             continue
         }
-        IF ($Line.StartsWith('ecdsa-')) {
+        if ($Line.StartsWith('ecdsa-')) {
             $null = Add-Content -Path $FixedPath -Value $Line
             continue
         }
-        if (-Not $HasBadLine) {
+        if (-not $HasBadLine) {
             $HasBadLine = $true
             Write-Host "Skipping lines that do not begin with ssh-, ecdsa- or #:" -ForegroundColor Red -BackgroundColor Black
         }
         Write-Host "    $Line" -ForegroundColor Yellow -BackgroundColor Black
     }
 
-    IF ($HasBadLine) {
+    if ($HasBadLine) {
         Write-Host "Unrecognized line formats were filtered out."
 
         $FixedPath
-        Return
+        return
     }
 
     Write-Verbose "No invalid keys were filtered out."
@@ -150,17 +150,17 @@ function Add-AuthorizedKey($UrlOrPath) {
     $IsHttp = $UrlOrPath.StartsWith("HTTP://", 'CurrentCultureIgnoreCase')
     $IsHttps = $UrlOrPath.StartsWith("HTTPS://", 'CurrentCultureIgnoreCase')
 
-    IF (Test-Path -Path $UrlOrPath -Type 'Leaf') {
+    if (Test-Path -Path $UrlOrPath -Type 'Leaf') {
         $FixedPath = Repair-AuthorizedKeyFile $UrlOrPath
         $null = Add-AuthorizedKeyFile $FixedPath
 
         $IsTmp = $UrlOrPath.EndsWith(".TMP.TXT", 'CurrentCultureIgnoreCase')
-        IF ($IsTmp) {
+        if ($IsTmp) {
             $null = Remove-Item -Path "${TmpKeys}.tmp.txt" -Force -ErrorAction Ignore
         }
-        Return
+        return
     }
-    IF (-Not ($IsHttps -Or $IsHttp)) {
+    if (-not ($IsHttps -or $IsHttp)) {
         throw "'$UrlOrPath' does not exist as a file and doesn't look like a URL (no https://)"
     }
 
@@ -169,7 +169,7 @@ function Add-AuthorizedKey($UrlOrPath) {
     curl.exe -f -sS $UrlOrPath | Out-File -Force "${TmpKeys}.partial"
     $null = Move-Item -Force "${TmpKeys}.partial" $TmpKeys
 
-    IF ($IsHttp) {
+    if ($IsHttp) {
         Write-Host ""
         Write-Host "Error: Cowardly refusing to add file downloaded over plain http" -ForegroundColor Yellow -BackgroundColor black
         Write-Host ""
@@ -177,7 +177,7 @@ function Add-AuthorizedKey($UrlOrPath) {
         Write-Host "    ssh-authorize ${TmpKeys}" -ForegroundColor Yellow -BackgroundColor black
         Write-Host ""
         1
-        Return
+        return
     }
 
     $FixedPath = Repair-AuthorizedKeyFile $TmpKeys
@@ -214,7 +214,7 @@ function Show-Help() {
     Write-Host ""
     Write-Host "LOCAL IDENTIFY FILES"
     $Pubs = Get-ChildItem -Path "$HOME\.ssh\" -Filter '*.pub'
-    IF ($Pubs.Length -eq 0) {
+    if ($Pubs.Length -eq 0) {
         Write-Host "    (no files match ~/.ssh/*.pub)"
     }
     foreach ($Pub in $Pubs) {
@@ -227,17 +227,17 @@ function Main($Paths) {
     $null = Repair-AuthorizedKeyPermission
     #Debug-AuthorizedKeyPermission | Write-Host
 
-    if ($Paths.Length -eq 0 -Or $Paths[0] -eq "help" -Or $Paths[0] -eq "--help") {
+    if ($Paths.Length -eq 0 -or $Paths[0] -eq "help" -or $Paths[0] -eq "--help") {
         Show-Help | Write-Host
 
         Write-Host ""
-        IF ($Paths.Length -eq 0) {
+        if ($Paths.Length -eq 0) {
             1
-            Return
+            return
         }
 
         0
-        Return
+        return
     }
     $Uri = $Paths[0]
 
@@ -253,8 +253,8 @@ function Main($Paths) {
     Write-Host ""
 
     0
-    Return
+    return
 }
 
 $Status = Main $Args
-Exit $Status
+exit $Status

ssh-pubkey/install.ps1

@@ -3,7 +3,7 @@
 $ErrorActionPreference = 'stop'
 
 function Install-WebiHostedScript () {
-    Param(
+    param(
         [string]$Package,
         [string]$ScriptName
     )

sttr/install.ps1

@@ -19,13 +19,13 @@ 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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
     Write-Output "Downloading sttr 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")) {
+if (!(Test-Path -Path "$pkg_src_cmd")) {
     Write-Output "Installing sttr"
 
     # TODO: create package-specific temp directory