Additions to kind cheatsheet

.github/ISSUE_TEMPLATE/new_installer.md

@@ -35,18 +35,15 @@ 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

.github/workflows/node.js.yml

@@ -1,37 +0,0 @@
-name: Node.js CI
-on:
-  push:
-    branches: ['main']
-  pull_request:
-jobs:
-  build:
-    name: "Fmt, Lint, & Test"
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version:
-          #- 20.x
-          - latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: "Webi: Install 'shfmt' and 'shellcheck', and update PATH"
-        run: |
-          sh ./_scripts/install-ci-deps
-          echo "${HOME}/.local/bin" >> $GITHUB_PATH
-          echo "${HOME}/.local/opt/pwsh" >> $GITHUB_PATH
-      - run: |
-          git submodule init
-          git submodule update
-      - run: shfmt --version
-      - run: shellcheck -V
-      - run: node --version
-      - run: npm run fmt
-      - run: npm ci
-      - run: npm run lint
-      - env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: npm run test

.gitignore

@@ -1,46 +1,6 @@
-# generated artifacts
+.env
+node_modules
 install-*.sh
 install-*.bat
 install-*.ps1
-
-# Go build outputs (from go run/build in repo root)
-/classify
-/e2etest
-/fetchraw
-/inspect
-/uaparse
-/webicached
-/zigtest
-/distributables.csv
-
-# local config
-.env.*
-*.env
-.env
-!example.env
-
-# caches
-_cache/
-node_modules/
-
-# local test fixtures (regenerated by _webi/test-live-*.js)
-testdata/
-LIVE_cache/
-distributables.csv
-
-# temporary & backup files
 .*.sw*
-*.bak
-*.bak.*
-
-# agent session files
-agents/
-LOCAL.md
-
-# other
-.DS_Store
-desktop.ini
-.directory
-LIVE_cache
-/webid
-bin/

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "_webi/build-classifier"]
-	path = _webi/build-classifier
-	url = https://github.com/webinstall/webi-build-classifier.git

.jshintignore

@@ -1,2 +0,0 @@
-node_modules/**/*
-_webi/test-*.js

.jshintrc

@@ -1,26 +0,0 @@
-{
-  "globals": {
-    "AbortController": false
-  },
-  "browser": true,
-  "node": true,
-  "esversion": 11,
-  "curly": true,
-  "sub": true,
-
-  "bitwise": true,
-  "eqeqeq": true,
-  "forin": true,
-  "freeze": true,
-  "immed": true,
-  "latedef": "nofunc",
-  "nonbsp": true,
-  "nonew": true,
-  "plusplus": true,
-  "undef": true,
-  "unused": "vars",
-  "strict": true,
-  "maxdepth": 4,
-  "maxstatements": 100,
-  "maxcomplexity": 20
-}

.prettierignore

@@ -1,4 +0,0 @@
-node_modules
-jsconfig.json
-package.json
-package-lock.json

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "none",
+  "tabWidth": 2,
+  "singleQuote": true,
+  "proseWrap": "always"
+}

.prettierrc.json

@@ -1,9 +0,0 @@
-{
-  "bracketSpacing": true,
-  "printWidth": 80,
-  "proseWrap": "always",
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "all",
-  "semi": true
-}

.vimrc

@@ -1,6 +0,0 @@
-" Note: You must enable per-project .vimrc in your ~/.vimrc
-" set secure
-" set exrc
-
-" PowerShell settings
-let g:ale_powershell_psscriptanalyzer_exclusions = "PSAvoidUsingWriteHost,PSUseDeclaredVarsMoreThanAssignments"

AGENTS.md

@@ -1,483 +0,0 @@
-# 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.
-
-## Domains
-
-| Environment | Domains                                          |
-| ----------- | ------------------------------------------------ |
-| Production  | webi.sh, webi.ms, webinstall.dev                 |
-| Beta        | beta.webi.sh, beta.webi.ms, beta.webinstall.dev  |
-| Next        | next.webi.sh, next.webi.ms, next.webinstall.dev  |
-
-- **webi.sh** — POSIX shell installer: `curl https://webi.sh/node | sh`
-- **webi.ms** — PowerShell installer: `curl.exe https://webi.ms/node | powershell`
-- **webinstall.dev** — canonical domain, serves both shell scripts and the
-  browser-facing cheat sheet pages
-
-The domain controls the default script format. You can force the same behavior
-on any domain via User-Agent:
-- `curl -A "MS" ...` — triggers PowerShell output (same as webi.ms)
-- `curl ...` (default UA) — triggers POSIX shell output (same as webi.sh)
-- `curl -A "$(uname -srm)" ...` — once the API is activated, the full
-  `uname -srm` string (e.g. `Linux 6.1.0 x86_64`) guides OS/arch selection
-
-## 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, `transform-releases.js` (API endpoint),
-  `builds-cacher.js` (reads cache JSON), `serve-installer.js` (installer
-  scripts)
-- `_common/` — shared JS fetcher libraries (being phased out — Go daemon now
-  fetches upstream)
-- `_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`       |
-
-## Data Architecture
-
-There are two data paths. Both read from pre-generated cache — the Node.js
-server does NOT fetch upstream APIs.
-
-```
-API path (JSON/TAB output):
-  Request → transform-releases.js → ~/.cache/webi/legacy/{pkg}.json → filter + sort
-  Vocabulary: macos, amd64, arm64, armv7l (API vocabulary)
-  normalize.js: REMOVED — cache provides all fields directly
-
-Installer path (bash/ps1 script output):
-  Request → serve-installer.js → builds.js → builds-cacher.js
-  Vocabulary: darwin, x86_64, aarch64 (build-classifier vocabulary)
-```
-
-Cache is generated by the Go daemon (`webicached`) and stored flat in
-`~/.cache/webi/legacy/{pkg}.json` (resolved via `Os.homedir()` in the Node
-readers — no `_cache` symlink, no month subdirectory). Each file contains:
-- Top-level summary arrays: `oses`, `arches`, `libcs`, `formats`
-- `releases` array with pre-classified fields: `os`, `arch`, `libc`, `ext`,
-  `version`, `channel`, `download`
-- `download` template string
-
-### Canonical vocabulary (cache and API)
-
-**OS**: `macos` (not darwin), `linux`, `windows`, `freebsd`, etc.
-**Arch**: `amd64` (not x86_64), `arm64` (not aarch64), `armv7l` (not armv7)
-**Libc**: `none` (never empty), `gnu`, `musl`, `msvc`
-**Ext**: `tar.gz`, `zip`, `exe` (no leading dot; `exe` for bare binaries)
-
-## releases.js (legacy — being phased out)
-
-The `{pkg}/releases.js` files previously fetched upstream release metadata.
-These are being replaced by the Go cache daemon. Existing files are kept as
-documentation of release sources but are no longer called by the server.
-
-### Testing the API (current)
-
-```sh
-curl -sS 'https://beta.webi.sh/api/releases/<name>.json?os=macos&arch=arm64&limit=5' | jq .
-```
-
-Verify: versions present, correct OS/arch vocabulary, 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.
-- **Cache directory**: `builds-cacher.js` and `transform-releases.js` read
-  exclusively from `~/.cache/webi/legacy/{pkg}.json` (resolved via
-  `Os.homedir()`). No date bucketing, no `_cache` symlink, no month rollover
-  hazard. If a package returns `0.0.0`, check that `~/.cache/webi/legacy/{pkg}.json`
-  exists and that `webicached` is running.
-- **Goreleaser archives**: Typically contain a bare binary at the archive root
-  (not nested in a directory). Use `mv ./cmd "$pkg_src_cmd"`.
-
----
-
-## Go Cache Daemon
-
-The Go pipeline (`cmd/webicached`) replaces the Node.js release-fetching code.
-It reads `releases.conf` files, fetches upstream release metadata, classifies
-build assets, and writes to `~/.cache/webi/legacy/` in the format the Node.js server expects.
-
-### Canonical Vocabulary
-
-The classifier MUST use exactly these strings. They match the production API.
-
-**OS**: `macos` (NOT `darwin`), `linux`, `windows`, `freebsd`, `openbsd`,
-`netbsd`, `dragonfly`, `aix`, `illumos`, `plan9`, `solaris`, `posix_2017`
-
-**Arch** — exact equivalences:
-- `amd64` (NOT `x86_64`), `x86` (NOT `i386`/`i686`/`386`)
-- `arm64` (NOT `aarch64`)
-- `armv7l` (NOT `armv7`), `armv6l` (NOT `armv6`)
-- `mipsle` (NOT `mipsel`), `mips64le` (NOT `mips64el`)
-
-**Arch** — compatibility downcasts:
-- `armhf` → `armv7l`, `armv7a` → `armv7l`, `armel` → `arm`
-
-**Arch** — other: `arm`, `ppc64le`, `ppc64`, `loong64`, `riscv64`, `s390x`,
-`mips`, `mips64`
-
-**Libc**: `none` (never empty), `gnu`, `musl`, `msvc`
-
-**Ext**: `tar.gz`, `tar.xz`, `zip`, `exe`, `7z`, `pkg`, `msi`
-(no leading dot; `exe` for bare binaries)
-
-### releases.conf
-
-Each package directory contains a `releases.conf` that tells the daemon where
-to fetch releases. Format is `key = value`, one per line. `#` comments and
-blank lines are ignored.
-
-#### Source types (mutually exclusive — pick one)
-
-```ini
-# GitHub binary releases (most common)
-github_releases = sharkdp/bat
-
-# GitHub source tarballs (with optional git fallback)
-github_sources = bnnanet/serviceman
-git_url = https://github.com/bnnanet/serviceman.git
-
-# Git tag enumeration (vim plugins, shell scripts — git_url alone)
-git_url = https://github.com/tpope/vim-commentary.git
-
-# Gitea (full URL required, or short form + base_url)
-gitea_releases = https://git.rootprojects.org/root/pathman
-
-# GitLab (defaults to gitlab.com)
-gitlab_releases = owner/repo
-
-# HashiCorp releases API
-hashicorp_product = terraform
-
-# Custom source (servicemandist, nodedist, zigdist, etc.)
-source = nodedist
-url = https://nodejs.org/download/release
-```
-
-#### Filtering, versioning, and platform
-
-```ini
-tag_prefix = bun-                    # monorepo: strip prefix from version
-version_prefixes = jq-               # strip from version string (space-separated)
-asset_filter = MinGit                # filename must contain this substring
-exclude = busybox -src- -docs-       # skip assets containing these (space-separated)
-os = posix_2017                      # restrict ALL versions to this OS (blanket)
-alias_of = rg                        # mirrors another package's releases
-```
-
-#### Design rules
-
-- `os` is a blanket tag on ALL versions. Only use for packages that are always
-  POSIX-only. For version-dependent OS tagging, use a custom `TagVariants` in
-  `internal/releases/{pkg}/variants.go`.
-- `git_url` can be primary (gittag source when it's the only key) or secondary
-  fallback alongside `github_sources`/`gitea_sources`.
-- Full URL forms accepted for github/gitea/gitlab (e.g.
-  `github_releases = https://github.com/sharkdp/bat`).
-
-### Testing
-
-Test tools: `cmd/e2etest` (pipeline comparison), `cmd/comparecache` (cache diff),
-`cmd/inspect` (single-package debug). Run each with `--help` for usage.
-
-### Classifier vs Per-Package Tagger
-
-The general classifier (`internal/classify/`) handles patterns common across
-many projects. It MUST NOT contain one-off logic for a single package.
-
-Per-package taggers (`internal/releases/{pkg}/variants.go`) handle
-project-specific knowledge. Read the existing taggers for conventions.
-
-MUST: Derive arch/OS from concrete evidence — not blanket defaults.
-MUST: New general classifier patterns must apply to 2-3+ packages.
-
-### Deploying
-
-```sh
-./scripts/deploy-webicached.sh beta.webi.sh
-./scripts/deploy-webicached.sh next.webi.sh
-```
-
-First-time setup on a new host uses `serviceman`:
-
-```sh
-serviceman add --name webicached \
-  --workdir ~/srv/webid/installers/ -- \
-  ~/bin/webicached \
-    --envfile ~/srv/webid/.env.secret \
-    --conf ~/srv/webid/installers/ \
-    --raw ~/.cache/webi/raw
-```

CONTRIBUTING.md

@@ -1,121 +0,0 @@
-# Guidelines for Contributing to Webi
-
-**Before you start**:
-
-- It's a good idea to try [Webi](https://webinstall.dev/) out for installing
-  developer tools for yourself before creating an installer.
-- It's also best if you take on issues for tools that you're familiar with.
-
-**Before you PR**:
-
-- 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
-      npm run prettier
-      ```
-    - [jshint](https://webinstall.dev/jshint)
-      ```sh
-      npm run lint
-      ```
-  - Bash
-    - [shfmt](https://webinstall.dev/shfmt)
-      ```sh
-      npm run shfmt
-      ```
-      Or
-      ```bash
-      shfmt -w -i 4 -sr -ci -s ./
-      ```
-    - [shellcheck](https://webinstall.dev/shellcheck) \
-      To check for all warnings and errors (except the ones we ignore):
-      ```bash
-      # to check all errors
-      shellcheck -s sh --exclude=SC2154,SC2034 */*.sh */*/*.sh
-      ```
-      To check for only specific warnings and errors:
-      ```bash
-      # to check specific errors
-      shellcheck -s sh --include=SC2005 */*.sh */*/*.sh
-      ```
-      Enumerated shellcheck codes:
-      <https://gist.github.com/nicerobot/53cee11ee0abbdc997661e65b348f375>
-    - Common exceptions:
-
-      ```text
-      # We make use of `.` (source) to import without exports
-      SC2034: foo appears unused. Verify it or export it.
-      SC2154: var is referenced but not assigned.
-      ```
-
-- If you use vim, [vim-essentials](https://webinstall.dev/vim-essentials)
-  includes everything you need to automatically format and lint on save.
-- If you use VS Code, the same plugins are also available in the VS Code store.
-
-**Not strictly mandatory, but we appreciate**:
-
-- [x] [Signed Commits](/git-config-gpg)
-- [x] Semantic Commit Messages
-- [x] Update `test` psuedo-package
-
-## Signed Commits
-
-Please **enable gpg-signing**.
-
-You can do this **in about 30 seconds**:
-
-1. Run [`git-config-gpg`](https://webinstall.dev/git-config-gpg) from Webi:
-   ```sh
-   # On Mac & Linux
-   curl https://webi.sh/git-config-gpg | sh
-   ```
-2. Copy the GPG public key (it will be printed to your screen)
-3. Add it to your GitHub profile: <https://github.com/settings/gpg/new>
-
-## Semantic Commit Messages
-
-We try to follow "semantic commits" to some degree. Especially since this is a
-project with many sub-projects.
-
-The general format is `<type>(<package>): <description>`, using these _types_:
-
-| _type_   | _usage_                                                            |
-| :------- | :----------------------------------------------------------------- |
-| feat     | new feature for the user, not a new feature for build script       |
-| fix      | bug fix for the user, not a fix to a build script                  |
-| docs     | changes to the documentation                                       |
-| style    | formatting, missing semi colons, etc; no production code change    |
-| refactor | refactoring production code, eg. renaming a variable               |
-| test     | adding missing tests, refactoring tests; no production code change |
-| chore    | updating grunt tasks etc; no production code change                |
-
-Try to write your commit messages (in the present tense) like this:
-
-```text
-fix(node): update install.sh (fix #200)
-```
-
-```text
-feat(delta): add cheat sheet and install.sh
-```
-
-```text
-docs(ssh-adduser): document that foo does bar
-```
-
-See <https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716> for
-some more examples.
-
-## Also update the `test` installer (a 3-line change)
-
-Whenever adding a new installer, please also update `test/install.sh`
-
-- `rm -rf ~/.local/opt/YOUR_PACKAGE`
-- `rm -f ~/.local/bin/YOUR_PACKAGE`
-- `webi YOUR_PACKAGE`
-- (and please keep it in alphabetical order)
-
-See
-<https://github.com/webinstall/webi-installers/pull/346/files#diff-db3af85ef45ed7ac0d1d9c473cf4d858657c127dc24d931fe18a9961f17e05b1>
-for an example.

README.md

@@ -2,15 +2,13 @@
 
 > [webi](https://webinstall.dev) is how developers install their tools
 
-[![webinstall-dev-ogimage-github](https://user-images.githubusercontent.com/122831/129465590-136b5a8a-f8f5-4e8d-a010-784eaa9f21bb.png)](https://webinstall.dev)
-
 - no `sudo`
 - no package manager
 - no messing with system permissions
 - in short: no nonsense
 
-```sh
-curl https://webi.sh/webi | sh
+```bash
+curl https://webinstall.dev/webi | bash
 ```
 
 This repository contains the primary and community-submitted packages for
@@ -32,7 +30,7 @@ More technically:
    - common release APIs are in `_common/` (i.e. `_common/github.js`)
 2. `_webi/bootstrap.sh` is a template that exchanges system information for a
    correct installer
-   - constructs a user agent with os, cpu, and utility info (i.e. `macos`,
+   - contructs a user agent with os, cpu, and utility info (i.e. `macos`,
      `amd64`, can unpack `tar,zip,xz`)
 3. `_webi/template.sh` is the base installer template with common functions for
    - checking versions
@@ -41,10 +39,10 @@ More technically:
    - (re-)linking directories
 4. `<package>/install.sh` may provide functions to override `_webi/template.sh`
 5. Recap:
-   - `curl https://webi.sh/<pkg>` => `bootstrap-<pkg>.sh`
-   - `sh bootstrap-<pkg>.sh` =>
+   - `curl https://webinstall.dev/<pkg>` => `bootstrap-<pkg>.sh`
+   - `bash bootstrap-<pkg>.sh` =>
      `https://webinstall.dev/api/installers/<pkg>@<ver>.sh?formats=zip,tar`
-   - `sh install-<pkg>.sh` => download, unpack, move, link, update PATH
+   - `bash install-<pkg>.sh` => download, unpack, move, link, update PATH
 
 # Philosophy (for package authors / maintainers publishing with webi)
 
@@ -73,7 +71,7 @@ An install consists of 5 parts in 4 files:
 my-new-package/
   - README.md (package info in frontmatter)
   - releases.js
-  - install.sh (POSIX Shell)
+  - install.sh (bash)
   - install.ps1 (PowerShell)
 ```
 
@@ -88,7 +86,7 @@ See these **examples**:
 - https://github.com/webinstall/packages/blob/master/golang/
 
 The `webinstall.dev` server uses the list of releases returned by
-`<your-package>/releases.js` to generate a shell script with most necessary
+`<your-package>/releases.js` to generate a bash script with most necessary
 variables and functions pre-defined.
 
 You just fill in the blanks.
@@ -97,14 +95,13 @@ You just fill in the blanks.
 
 Just create an empty directory and run the tests until you get a good result.
 
-```sh
-git clone git@github.com:webinstall/webi-installers.git
-pushd ./webi-installers/
-git submodule update --init
-npm clean-install
+```bash
+git clone git@github.com:webinstall/packages.git
+pushd packages
+npm install
 ```
 
-```sh
+```bash
 mkdir -p ./new-package/
 node _webi/test.js ./new-package/
 ```
@@ -119,13 +116,12 @@ Just copy the format from any of the existing packages. It's like this:
 ---
 title: Node.js
 homepage: https://nodejs.org
-tagline: |
-  JavaScript V8 runtime
+tagline: JavaScript V8 runtime
 description: |
   Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine
 ---
 
-```sh
+```bash
 node -e 'console.log("Hello, World!")'
 > Hello, World!
 ```
@@ -145,8 +141,8 @@ It looks like this:
 `releases.js`:
 
 ```js
-module.exports = function () {
-  return github(null, owner, repo).then(function (all) {
+module.exports = function (request) {
+  return github(request, owner, repo).then(function (all) {
     // if you need to do something special, you can do it here
     // ...
     return all;
@@ -162,7 +158,7 @@ module.exports = function () {
 
 (optional, if needed) Bash variables that you _may_ define:
 
-```sh
+```bash
 # Define this if the package name is different from the command name (i.e. golang => go)
 pkg_cmd_name="foobar"
 
@@ -179,16 +175,16 @@ pkg_src_cmd="$HOME/.local/opt/foobar-v$WEBI_VERSION/bin/foobar"
 
 (required) A version check function that strips all non-version junk
 
-```sh
+```bash
 pkg_get_current_version() {
     # foobar-v1.1.7 => 1.1.7
     echo "$(foobar --version | head -n 1 | sed 's:foobar-v::')"
 }
 ```
 
-For the rest of the functions you can copy/paste from the examples:
+For the rest of the functions you can like copy/paste from the examples:
 
-```sh
+```bash
 pkg_format_cmd_version() {}         # Override, pretty prints version
 
 pkg_link                            # Override, replaces webi_link()
@@ -215,7 +211,7 @@ See `webi/template.sh`
 
 These variables will be set by the server:
 
-```sh
+```bash
 WEBI_PKG=example@v1
 WEBI_TAG=v1
 WEBI_HOST=https://webinstall.dev
@@ -232,21 +228,21 @@ WEBI_PKG_URL=https://cdn.example.com/example-macos-amd64.tar.gz
 WEBI_PKG_FILE=example-macos-amd64.tar.gz
 ```
 
-```sh
+```bash
 PKG_NAME=example
 PKG_OSES=macos,linux,windows
 PKG_ARCHES=amd64,arm64,x86
 PKG_FORMATS=zip,xz
 ```
 
-```sh
+```bash
 WEBI_TMP=${WEBI_TMP:-"$(mktemp -d -t webinstall-foobar.XXXXXXXX)"}
 WEBI_SINGLE=""
 ```
 
-```sh
+```bash
 webi_check              # Checks to see if the selected version is already installed (and re-links if so)
-webi_download           # Downloads the selected release to $HOME/Downloads/webi/<package-name>.tar.gz
+webi_download           # Downloads the selected release to $HOME/Downloads/<package-name>.tar.gz
 webi_extract            # Extracts the download to /tmp/<package-name>-<random>/
 webi_path_add /new/path # Adds /new/path to PATH for bash, zsh, and fish
 webi_pre_install        # Runs webi_check, webi_download, and webi_extract
@@ -271,10 +267,10 @@ webi_post_install       # Runs `webi_path_add $pkg_dst_bin`
 set WEBI_HOST=https://webinstall.dev
 ```
 
-Windows has curl too!?
+Windows 10 has curl too!?
 
 ```bat
-curl.exe -sL https://webi.ms/node | powershell
+curl.exe -sL -A "MS" https://webinstall.dev/node | powershell
 ```
 
 And it's easy enough to ignore the execution policy
@@ -287,11 +283,11 @@ And if we want something that looks as complicated as we expect Windows to be,
 historically, we have options:
 
 ```bat
-powershell "Invoke-Expression ( Invoke-WebRequest -UseBasicParsing https://webi.ms/node ).Contents"
+powershell "Invoke-Expression ( Invoke-WebRequest -UseBasicParsing https://webinstall.dev/node ).Contents"
 ```
 
 ```bat
-powershell ( Invoke-WebRequest -UseBasicParsing https://webi.ms/node ).Contents | powershell
+powershell ( Invoke-WebRequest -UseBasicParsing https://webinstall.dev/node ).Contents | powershell
 ```
 
 -->

_common/brew.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Gets a releases from 'brew'.
+ *
+ * @param request
+ * @param {string} formula
+ * @returns {PromiseLike<any> | Promise<any>}
+ */
+function getAllReleases(request, formula) {
+  if (!formula) {
+    return Promise.reject('missing formula for brew');
+  }
+  return request({
+    url: 'https://formulae.brew.sh/api/formula/' + formula + '.json',
+    fail: true, // https://git.coolaj86.com/coolaj86/request.js/issues/2
+    json: true
+  })
+    .then(failOnBadStatus)
+    .then(function (resp) {
+      var ver = resp.body.versions.stable;
+      var dl = (
+        resp.body.bottle.stable.files.high_sierra ||
+        resp.body.bottle.stable.files.catalina
+      ).url.replace(new RegExp(ver.replace(/\./g, '\\.'), 'g'), '{{ v }}');
+      return [
+        {
+          version: ver,
+          download: dl.replace(/{{ v }}/g, ver)
+        }
+      ].concat(
+        resp.body.versioned_formulae.map(function (f) {
+          var ver = f.replace(/.*@/, '');
+          return {
+            version: ver,
+            download: dl
+          };
+        })
+      );
+    })
+    .catch(function (err) {
+      console.error('Error fetching MariaDB versions (brew)');
+      console.error(err);
+      return [];
+    });
+}
+
+function failOnBadStatus(resp) {
+  if (resp.statusCode >= 400) {
+    var err = new Error('Non-successful status code: ' + resp.statusCode);
+    err.code = 'ESTATUS';
+    err.response = resp;
+    throw err;
+  }
+  return resp;
+}
+
+module.exports = getAllReleases;
+
+if (module === require.main) {
+  getAllReleases(require('@root/request'), 'mariadb').then(function (all) {
+    console.info(JSON.stringify(all, null, 2));
+  });
+}

_common/gitea.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var ghRelease = require('./github.js');
+
+/**
+ * Gets the releases for 'ripgrep'. This function could be trimmed down and made
+ * for use with any github release.
+ *
+ * @param request
+ * @param {string} owner
+ * @param {string} repo
+ * @returns {PromiseLike<any> | Promise<any>}
+ */
+function getAllReleases(request, owner, repo, baseurl) {
+  if (!baseurl) {
+    return Promise.reject('missing baseurl');
+  }
+  return ghRelease(request, owner, repo, baseurl + '/api/v1').then(function (
+    all
+  ) {
+    return all;
+  });
+}
+
+module.exports = getAllReleases;
+
+if (module === require.main) {
+  getAllReleases(
+    require('@root/request'),
+    'coolaj86',
+    'go-pathman',
+    'https://git.coolaj86.com'
+  ).then(
+    //getAllReleases(require('@root/request'), 'root', 'serviceman', 'https://git.rootprojects.org').then(
+    function (all) {
+      console.info(JSON.stringify(all, null, 2));
+    }
+  );
+}

_common/github.js

@@ -0,0 +1,76 @@
+'use strict';
+
+require('dotenv').config();
+
+/**
+ * Gets the releases for 'ripgrep'. This function could be trimmed down and made
+ * for use with any github release.
+ *
+ * @param request
+ * @param {string} owner
+ * @param {string} repo
+ * @returns {PromiseLike<any> | Promise<any>}
+ */
+function getAllReleases(
+  request,
+  owner,
+  repo,
+  baseurl = 'https://api.github.com'
+) {
+  if (!owner) {
+    return Promise.reject('missing owner for repo');
+  }
+  if (!repo) {
+    return Promise.reject('missing repo name');
+  }
+
+  var req = {
+    url: `${baseurl}/repos/${owner}/${repo}/releases`,
+    json: true
+  };
+  // TODO I really don't like global config, find a way to do better
+  if (process.env.GITHUB_USERNAME) {
+    req.auth = {
+      user: process.env.GITHUB_USERNAME,
+      pass: process.env.GITHUB_TOKEN
+    };
+  }
+
+  return request(req).then((resp) => {
+    const gHubResp = resp.body;
+    const all = {
+      releases: [],
+      // todo make this ':baseurl' + ':releasename'
+      download: ''
+    };
+
+    gHubResp.forEach((release) => {
+      release['assets'].forEach((asset) => {
+        const name = asset['name'];
+        all.releases.push({
+          name: name,
+          version: release['tag_name'], // TODO tags aren't always semver / sensical
+          lts: /(\b|_)(lts)(\b|_)/.test(release['tag_name']),
+          channel: !release['prerelease'] ? 'stable' : 'beta',
+          date: (release['published_at'] || '').replace(/T.*/, ''),
+          os: '', // will be guessed by download filename
+          arch: '', // will be guessed by download filename
+          ext: '', // will be normalized
+          download: asset['browser_download_url']
+        });
+      });
+    });
+
+    return all;
+  });
+}
+
+module.exports = getAllReleases;
+
+if (module === require.main) {
+  getAllReleases(require('@root/request'), 'BurntSushi', 'ripgrep').then(
+    function (all) {
+      console.info(JSON.stringify(all, null, 2));
+    }
+  );
+}

_example/README.md

@@ -15,17 +15,6 @@ tagline: |
 To update or switch versions, run `webi example@stable` (or `@v2`, `@beta`,
 etc).
 
-### Files
-
-These are the files / directories that are created and/or modified with this
-install:
-
-```text
-~/.config/envman/PATH.env
-~/.local/bin/foo
-~/.local/opt/foo/
-```
-
 ## Cheat Sheet
 
 > `foo` doesn't exist and this text should have been replaced. It doesn't do
@@ -33,7 +22,7 @@ install:
 
 To run foo:
 
-```sh
+```bash
 foo
 ```
 
@@ -41,6 +30,6 @@ foo
 
 To run foo with both bar and baz highlighting turned on:
 
-```sh
+```bash
 foo --bar=baz
 ```

_example/install.ps1

@@ -15,45 +15,47 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\foobar-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\foobar-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"
+$pkg_download = "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
-    Write-Output "Downloading foobar from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE"))
+{
+    # TODO: arch detection
+    echo "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"
+    & move "$pkg_download.part" "$pkg_download"
 }
 
-if (!(Test-Path -Path "$pkg_src_cmd")) {
-    Write-Output "Installing foobar"
+IF (!(Test-Path -Path "$pkg_src_cmd"))
+{
+    echo "Installing foobar"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    Push-Location .local\tmp
+    pushd .local\tmp
 
-    # Remove any leftover tmp cruft
-    Remove-Item -Path ".\foobar-v*" -Recurse -ErrorAction Ignore
-    Remove-Item -Path ".\foo.exe" -Recurse -ErrorAction Ignore
+        # Remove any leftover tmp cruft
+        Remove-Item -Path ".\foobar-v*" -Recurse -ErrorAction Ignore
+        Remove-Item -Path ".\foo.exe" -Recurse -ErrorAction Ignore
 
-    # NOTE: DELETE THIS COMMENT IF NOT USED
-    # Move single binary into root of temporary folder
-    #& move "$pkg_download" "foo.exe"
+        # NOTE: DELETE THIS COMMENT IF NOT USED
+        # Move single binary into root of temporary folder
+        #& move "$pkg_download" "foo.exe"
 
-    # Unpack archive file into this temporary directory
-    # Windows BSD-tar handles zip. Imagine that.
-    Write-Output "Unpacking $pkg_download"
-    & tar xf "$pkg_download"
+        # Unpack archive file into this temporary directory
+        # Windows BSD-tar handles zip. Imagine that.
+        echo "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 ".\foobar-*\foo.exe" -Destination "$pkg_src_bin"
+        # Settle unpacked archive into place
+        echo "Install Location: $pkg_src_cmd"
+        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+        Move-Item -Path ".\foobar-*\foo.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    Pop-Location
+    popd
 }
 
-Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
+echo "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

_example/install.sh

@@ -1,9 +1,6 @@
-#!/bin/sh
+#!/bin/bash
 
-# shellcheck disable=SC2034
-# "'pkg_cmd_name' appears unused. Verify it or export it."
-
-__init_foobar() {
+function __init_foobar() {
     set -e
     set -u
 
@@ -24,21 +21,19 @@ __init_foobar() {
     # pkg_install must be defined by every package
     pkg_install() {
         # ~/.local/opt/foobar-v0.99.9/bin
-        mkdir -p "$(dirname "${pkg_src_cmd}")"
+        mkdir -p "$(dirname $pkg_src_cmd)"
 
         # mv ./foobar-*/foo ~/.local/opt/foobar-v0.99.9/bin/foo
-        mv ./foobar-*/foo "${pkg_src_cmd}"
+        mv ./foobar-*/foo "$pkg_src_cmd"
     }
 
-    # pkg_get_current_version is recommended, but not required
+    # pkg_get_current_version is recommended, but (soon) not required
     pkg_get_current_version() {
         # 'foo --version' has output in this format:
         #       foobar 0.99.9 (rev abcdef0123)
         # This trims it down to just the version number:
         #       0.99.9
-        foo --version 2> /dev/null |
-            head -n 1 |
-            cut -d ' ' -f 2
+        echo $(foo --version 2> /dev/null | head -n 1 | cut -d ' ' -f 2)
     }
 
 }

_example/releases.conf

@@ -1,3 +0,0 @@
-# Example releases.conf — uses ripgrep as a sample project.
-# Copy this file into your package directory and adjust.
-github_releases = BurntSushi/ripgrep

_example/releases.js

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

_examples/built-with-goreleaser/README.md

@@ -16,7 +16,7 @@ Each example has four files that need to be modified, just slightly:
 
 See [./keypairs/](/keypairs/) as an example.
 
-```sh
+```bash
 rsync -av ./keypairs/ ./my-project/
 ```
 
@@ -26,7 +26,7 @@ Keypairs is packaged for Mac and Linux as `.tar.gz`, and as `.zip` for Windows.
 
 See [./arc/](/arc/) as an example.
 
-```sh
+```bash
 rsync -av ./arc/ ./my-project/
 ```
 

_examples/compressed-with-xz/README.md

@@ -16,7 +16,7 @@ Each example has four files that need to be modified, just slightly:
 
 See [./gitea/](/gitea/) as an example.
 
-```sh
+```bash
 rsync -av ./keypairs/ ./my-project/
 ```
 

_npm/README.md

@@ -11,7 +11,7 @@ Effortlessly install developer tools with easy-to-remember URLs.
 
 ## Install webi via npm:
 
-```sh
+```bash
 npm install -g webi
 ```
 
@@ -19,14 +19,14 @@ npm install -g webi
 
 Mac & Linux:
 
-```sh
-curl -fsS https://webi.sh/node | sh
+```bash
+curl -fsS https://webinstall.dev/node | bash
 ```
 
-Windows (includes `curl.exe` and PowerShell by default):
+Windows 10 (includes `curl.exe` and PowerShell by default):
 
-```sh
-curl.exe -fsSA "MS" https://webi.ms/node | powershell
+```bash
+curl.exe -fsSA "MS" https://webinstall.dev/node | powershell
 ```
 
 ## Example: Switching node versions
@@ -34,7 +34,7 @@ curl.exe -fsSA "MS" https://webi.ms/node | powershell
 Once `webi` is installed, you can then install commands or switch versions with
 webi itself:
 
-```sh
+```bash
 webi node@stable
 webi node@lts
 webi node@v10

_npm/lib/exec.js

@@ -1,12 +1,15 @@
 'use strict';
 
+var pkg = require('../package.json');
 var spawn = require('child_process').spawn;
+var os = require('os');
+var path = require('path');
 
 function spawner(args) {
   return new Promise(function (resolve, reject) {
     var bin = args.shift();
     var runner = spawn(bin, args, {
-      windowsHide: true,
+      windowsHide: true
     });
     runner.stdout.on('data', function (chunk) {
       console.info(chunk.toString('utf8'));

_npm/scripts/install-webi.js

@@ -4,6 +4,7 @@
 
 //var pkg = require('../package.json');
 var os = require('os');
+//var request = require('@root/request');
 //var promisify = require('util').promisify;
 //var exec = promisify(require('child_process').exec);
 var exec = require('child_process').exec;
@@ -13,12 +14,18 @@ if (/^win/i.test(os.platform())) {
   console.warn("This npm installer doesn't work on windows yet.");
   console.warn('Copy and paste this into cmd.exe or PowerShell instead:');
   console.warn('');
-  console.warn('    curl.exe -fsS https://webi.ms/webi | powershell');
+  console.warn(
+    "    curl.exe -fsSA 'MS' https://webinstall.dev/webi | powershell"
+  );
   console.warn('');
   return;
 }
 
-exec('curl -fsS https://webi.sh/webi | sh', function (err, stdout, stderr) {
+exec('curl -fsS https://webinstall.dev/webi | bash', function (
+  err,
+  stdout,
+  stderr
+) {
   if (err) {
     console.error(err);
   }

_scripts/deploy-webinstall

@@ -1,100 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-# Deploy the Node.js webinstall (installer server) to a target host.
-# Usage: _scripts/deploy-webinstall <host>
-#   e.g. _scripts/deploy-webinstall beta.webi.sh
-#        _scripts/deploy-webinstall next.webi.sh
-
-fn_main() {
-    g_host="${1:-}"
-    if test -z "${g_host}"; then
-        printf 'Usage: %s <host>\n' "$0" >&2
-        printf '  e.g. %s beta.webi.sh\n' "$0" >&2
-        exit 1
-    fi
-
-    # beta.webi.sh → ~/srv/beta.webinstall.dev/installers/
-    # next.webi.sh → ~/srv/next.webinstall.dev/installers/
-    b_subdomain="${g_host%%.*}"
-    g_dest="~/srv/${b_subdomain}.webinstall.dev/installers/"
-
-    # Verify the build-classifier submodule is populated. rsync will
-    # happily push an empty submodule directory, after which Node
-    # crashes at startup with `Cannot find module './build-classifier/
-    # host-targets.js'`. New worktrees from `git worktree add` don't
-    # init submodules by default.
-    if ! test -f ./_webi/build-classifier/host-targets.js; then
-        printf 'fatal: _webi/build-classifier submodule not initialized\n' >&2
-        printf '  run: git submodule update --init _webi/build-classifier\n' >&2
-        exit 1
-    fi
-
-    printf '%s\n' "Deploying to ${g_host}:${g_dest} ..."
-
-    rsync -avz --delete \
-        --exclude='.git' \
-        --exclude='node_modules' \
-        --exclude='_cache' \
-        --exclude='LIVE_cache' \
-        --exclude='webicached' \
-        --exclude='classify' \
-        --exclude='fetchraw' \
-        --exclude='inspect' \
-        --exclude='e2etest' \
-        --exclude='zigtest' \
-        --exclude='distributables.csv' \
-        --exclude='agents/' \
-        ./ "${g_host}:${g_dest}"
-
-    printf '%s\n' "Restarting webinstall ..."
-
-    # shellcheck disable=SC2029
-    ssh "${g_host}" "
-        . ~/.config/envman/PATH.env 2>/dev/null
-        rm -rf ${g_dest}_cache 2>/dev/null
-        serviceman restart webinstall
-    "
-
-    printf '%s\n' "Waiting for restart ..."
-    sleep 3
-
-    fn_smoke_test
-}
-
-fn_smoke_test() {
-    printf '%s\n' "Smoke testing https://${g_host}/ ..."
-
-    b_headers="$(curl -sI --max-time 5 "https://${g_host}/api/releases/go.json?limit=1")"
-
-    if printf '%s' "${b_headers}" | grep -qi 'X-Robots-Tag: noindex'; then
-        printf '%s\n' "  [ok] X-Robots-Tag: noindex"
-    else
-        printf '%s\n' "  [FAIL] Missing X-Robots-Tag header"
-    fi
-
-    if printf '%s' "${b_headers}" | grep -qi 'rel="canonical"'; then
-        printf '%s\n' "  [ok] Link: canonical"
-    else
-        printf '%s\n' "  [FAIL] Missing canonical Link header"
-    fi
-
-    b_version="$(curl -sS --max-time 5 "https://${g_host}/api/releases/go.json?limit=1" | jq -r '.[0].version')"
-    if test "${b_version}" != "0.0.0" && test -n "${b_version}"; then
-        printf '%s\n' "  [ok] API returns go ${b_version}"
-    else
-        printf '%s\n' "  [FAIL] API returned error or empty for go"
-    fi
-
-    b_shebang="$(curl -sS --max-time 5 "https://${g_host}/node" | head -1)"
-    if test "${b_shebang}" = "#!/bin/sh"; then
-        printf '%s\n' "  [ok] Installer path serves shell script"
-    else
-        printf '%s\n' "  [FAIL] Installer path unexpected: ${b_shebang}"
-    fi
-
-    printf '%s\n' "Done."
-}
-
-fn_main "$@"

_scripts/git-hooks-init.js

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-var Fs = require('node:fs/promises');
-var Path = require('node:path');
-
-async function copyScripts() {
-  var pkgDir = Path.join(__dirname, '..');
-  var scriptsDir = Path.join(pkgDir, '_scripts');
-  var gitFile = Path.join(pkgDir, '.git');
-
-  // if this is a submodule, '.git' will be a file with a
-  // path to the actual git module directory
-  var gitDir = await Fs.readFile(gitFile, 'utf8')
-    .catch(function (e) {
-      // console.error(e);
-      //return 'gitdir: ../.git/modules/installers';
-      return 'gitdir: ./.git';
-    })
-    .then(function (str) {
-      var parts = str.split(': ');
-      str = parts[1];
-      str = str.trim();
-
-      return Path.resolve(pkgDir, str);
-    });
-
-  var gitHooksDir = Path.join(gitDir, 'hooks');
-
-  var src = Path.join(scriptsDir, 'git-hooks-pre-commit.js');
-  var dst = Path.join(gitHooksDir, 'pre-commit');
-
-  console.info(`[git-hooks] Checking for pre-commit hooks...`);
-  var relSrc = Path.relative(pkgDir, src);
-  var relDst = Path.relative(pkgDir, dst);
-  await Fs.access(dst)
-    .then(function () {
-      console.info(`[git-hooks] Found ${relDst}`);
-    })
-    .catch(async function (e) {
-      // ignore e
-      await Fs.mkdir(gitHooksDir, { recursive: true });
-      await Fs.copyFile(src, dst);
-      await Fs.chmod(dst, 0o755);
-      console.info(`[git-hooks] Found template ${relSrc}`);
-      console.info(`[git-hooks] Initialized ${relDst}`);
-    });
-}
-
-copyScripts()
-  .then(function () {
-    process.exit(0);
-  })
-  .catch(function (e) {
-    console.error(e);
-    process.exit(1);
-  });

_scripts/git-hooks-pre-commit

@@ -1,7 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-npm run fmt
-npm run lint
-npm run test

_scripts/git-hooks-pre-commit.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-var Process = require('child_process');
-
-var procOpts = { stdio: 'inherit' };
-var commands = ['npm run fmt', 'npm run lint', 'npm run test'];
-
-for (let cmd of commands) {
-  console.info(`[pre-commit] exec: ${cmd}`);
-  Process.execSync(cmd, procOpts);
-}

_scripts/install-ci-deps

@@ -1,15 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-# Install 'shfmt 3.7.x'
-curl -fsS https://webi.sh/shfmt@3.7 | sh
-
-# Install 'shellcheck v0.9.x'
-curl -fsS https://webi.sh/shellcheck@0.9 | sh
-
-# Install 'pwsh (PowerShell Core) v7.x'
-curl -fsS https://webi.sh/pwsh@7 | sh
-# shellcheck disable=SC1090
-. ~/.config/envman/PATH.env
-pwsh -Command "Install-Module -Name PSScriptAnalyzer -Scope CurrentUser -AllowClobber"

_scripts/pwsh-fmt

@@ -1,27 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-echo "Formatting */*.ps1 ... "
-for my_ps1 in */*.ps1; do
-    my_dir="$(
-        dirname "${my_ps1}"
-    )"
-    if test -L "${my_ps1}" ||
-        test -L "${my_dir}" ||
-        ! test -f "${my_ps1}" ||
-        ! test -d "${my_dir}"; then
-        printf '    SKIP %s (non-regular file or parent directory)\n' "${my_ps1}"
-        continue
-    fi
-
-    printf "    %s" "${my_ps1}"
-
-    # -Settings ./Settings/CodeFormatting.psd1
-    my_new_file="$(
-        pwsh -Command "Invoke-Formatter -ScriptDefinition (Get-Content -Path '${my_ps1}' -Raw)"
-    )"
-    printf '%s\n' "${my_new_file}" > "${my_ps1}"
-
-    printf '\n'
-done

_scripts/pwsh-fmt.ps1

@@ -1,40 +0,0 @@
-#!/usr/bin/env pwsh
-
-$ErrorActionPreference = "Stop"
-
-Write-Host "Formatting */*.ps1 ... "
-
-$my_cwd = Get-Location
-$my_dirs = Get-ChildItem -Directory
-$my_status = 0
-
-foreach ($my_dir in $my_dirs) {
-
-    $my_files = Get-ChildItem -Path $my_dir.FullName -File -Filter *.ps1
-    foreach ($my_file in $my_files) {
-        $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)) {
-            Write-Host ("    SKIP {0} (non-regular file or parent directory)" -f $my_ps1)
-            continue
-        }
-
-        Write-Host ("    {0}" -f $my_ps1)
-
-        $text = Get-Content -Path $my_ps1 -Raw
-        $my_new_file = Invoke-Formatter -ScriptDefinition $text
-        $my_new_file = $my_new_file.Trim()
-
-        # note: trailing newline is added back on write
-        $my_new_file | Set-Content -Path $my_ps1
-
-        $my_new_file = $my_new_file + "`n"
-        if ($text -ne $my_new_file) {
-            $my_status = 1
-        }
-    }
-}
-
-exit $my_status

_scripts/pwsh-lint

@@ -1,36 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-echo "Formatting */*.ps1 ..."
-
-for my_ps1 in */*.ps1; do
-    my_dir="$(
-        dirname "${my_ps1}"
-    )"
-    if test -L "${my_ps1}" ||
-        test -L "${my_dir}" ||
-        ! test -f "${my_ps1}" ||
-        ! test -d "${my_dir}"; then
-        printf '    SKIP %s (non-regular file or parent directory)\n' "${my_ps1}"
-        continue
-    fi
-
-    printf "    %s" "${my_ps1}"
-
-    # -Settings ./PSScriptAnalyzerSettings.psd1
-    pwsh -Command "Invoke-ScriptAnalyzer -Fix -ExcludeRule PSAvoidUsingWriteHost,PSUseDeclaredVarsMoreThanAssignment -Path '$my_ps1'"
-
-    #
-    # fmt MUST happen after lint due to Byte-Order Marker (BOM) issues
-    # See https://github.com/PowerShell/PSScriptAnalyzer/issues/1743
-    #
-
-    # -Settings ./Settings/CodeFormatting.psd1
-    my_new_file="$(
-        pwsh -Command "Invoke-Formatter -ScriptDefinition (Get-Content -Path '${my_ps1}' -Raw)"
-    )"
-    printf '%s\n' "${my_new_file}" > "${my_ps1}"
-
-    printf '\n'
-done

_scripts/pwsh-lint.ps1

@@ -1,48 +0,0 @@
-#!/usr/bin/env pwsh
-
-$ErrorActionPreference = "Stop"
-
-Write-Host "Linting */*.ps1 ... "
-
-$my_cwd = Get-Location
-$my_dirs = Get-ChildItem -Directory
-$my_status = 0
-
-foreach ($my_dir in $my_dirs) {
-
-    $my_files = Get-ChildItem -Path $my_dir.FullName -File -Filter *.ps1
-    foreach ($my_file in $my_files) {
-        $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)) {
-            Write-Host ("    SKIP {0} (non-regular file or parent directory)" -f $my_ps1)
-            continue
-        }
-
-        Write-Host ("    {0}" -f $my_ps1)
-
-        $my_old_file = (Get-Content -Path $my_ps1 -Raw)
-        Invoke-ScriptAnalyzer -Fix -ExcludeRule PSAvoidUsingWriteHost, PSUseDeclaredVarsMoreThanAssignment -Path $my_ps1
-
-        #
-        # fmt MUST happen after lint due to Byte-Order Marker (BOM) issues
-        # See https://github.com/PowerShell/PSScriptAnalyzer/issues/1743
-        #
-
-        $my_fixed_file = (Get-Content -Path $my_ps1 -Raw)
-        $my_new_file = Invoke-Formatter -ScriptDefinition $my_fixed_file
-        $my_new_file = $my_new_file.Trim()
-
-        # note: trailing newline is added back on write
-        $my_new_file | Set-Content -Path $my_ps1
-
-        $my_new_file = $my_new_file + "`n"
-        if ($my_old_file -ne $my_new_file) {
-            $my_status = 1
-        }
-    }
-}
-
-exit $my_status

_scripts/tooling-init.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-var Cmd = require('node:child_process');
-var Os = require('node:os');
-
-var procOpts = { stdio: 'inherit' };
-var commands = ['shfmt --version', 'shellcheck --version'];
-
-for (let cmd of commands) {
-  console.info(`[tooling-init] checking for '${cmd}':`);
-  try {
-    Cmd.execSync(cmd, procOpts);
-  } catch (e) {
-    // ignore e
-    printInstallHelp(cmd);
-    process.exit(1);
-  }
-}
-
-function printInstallHelp(cmd) {
-  console.error('');
-  console.error('ERROR');
-  console.error(`        could not run '${cmd}'`);
-  console.error('POSSIBLE FIX');
-  if (/^win/i.test(Os.platform())) {
-    console.error(`        curl.exe https://webi.ms/${cmd} | powershell`);
-  } else {
-    console.error(`        curl -fsS https://webi.sh/${cmd} | sh`);
-  }
-  console.error('');
-}

_vim-example/README.md

@@ -26,7 +26,7 @@ If there are some important key bindings, use a table like this:
 
 1. Place EXAMPLE into your `~/.vim/pack/plugins/start`:
 
-   ```sh
+   ```bash
    mkdir -p ~/.vim/pack/plugins/start/
    git clone --depth=1 https://github.com/CHANGEME/EXAMPLE.git ~/.vim/pack/plugins/start/example
    ```

_vim-example/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
-if (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
-    New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
+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
 & git clone --depth=1 https://github.com/CHANGEME/example.git "$Env:USERPROFILE\.vim\pack\plugins\start\example"

_vim-example/install.sh

@@ -1,6 +1,6 @@
-#!/bin/sh
+#!/bin/bash
 
-__init_vim_example() {
+function __init_vim_example() {
     set -e
     set -u
 

_webi/bootstrap.bat

@@ -0,0 +1,28 @@
+setlocal
+@echo off
+pushd "%userprofile%" || goto :error
+  IF NOT EXIST .local (
+    mkdir .local || goto :error
+  )
+  IF NOT EXIST .local\bin (
+    mkdir .local\bin || goto :error
+  )
+
+  rem {{ baseurl }}
+  rem {{ version }}
+  pushd .local\bin || goto :error
+    if NOT EXIST webi.bat (
+      rem without SilentlyContinue this is SLOOOOOOOOOOOOOOOW!
+      powershell $ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest https://webinstall.dev/packages/_webi/webi.bat -OutFile webi.bat || goto :error
+    )
+    call .\webi {{ exename }} || goto :error
+    rem pathman add "%userprofile%\.local\bin" >nul 2>&1 || goto :error
+    pathman add "%userprofile%\.local\bin" || goto :error
+  popd || goto :error
+popd
+
+goto :EOF
+
+:error
+echo Failed with error #%errorlevel%.
+exit /b %errorlevel%

_webi/bootstrap.ps1

@@ -0,0 +1,6 @@
+# Download the latest webi, then install {{ exename }}
+New-Item -Path .local\bin -ItemType Directory -Force | out-null
+IF ($Env:WEBI_HOST -eq $null -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"
+Set-ExecutionPolicy -Scope Process Bypass
+& "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" "{{ exename }}"

_webi/bootstrap.sh

@@ -0,0 +1,172 @@
+#!/bin/bash
+
+#set -x
+
+function __install_webi() {
+
+    #WEBI_PKG=
+    #WEBI_HOST=https://webinstall.dev
+    export WEBI_HOST
+
+    echo ""
+    echo "Thanks for using webi to install '${WEBI_PKG:-}' on '$(uname -s)/$(uname -m)'."
+    echo "Have a problem? Experience a bug? Please let us know:"
+    echo "        https://github.com/webinstall/packages/issues"
+    echo ""
+    WEBI_WELCOME=true
+    export WEBI_WELCOME
+
+    set -e
+    set -u
+
+    mkdir -p "$HOME/.local/bin"
+
+    cat << EOF > "$HOME/.local/bin/webi"
+#!/bin/bash
+
+set -e
+set -u
+#set -x
+
+function __webi_main () {
+
+    export WEBI_TIMESTAMP=\$(date +%F_%H-%M-%S)
+    export _webi_tmp="\${_webi_tmp:-\$(mktemp -d -t webi-\$WEBI_TIMESTAMP.XXXXXXXX)}"
+
+    if [ -n "\${_WEBI_PARENT:-}" ]; then
+        export _WEBI_CHILD=true
+    else
+        export _WEBI_CHILD=
+    fi
+    export _WEBI_PARENT=true
+
+    ##
+    ## Detect acceptable package formats
+    ##
+
+    my_ext=""
+    set +e
+    # NOTE: the order here is least favorable to most favorable
+    if [ -n "\$(command -v pkgutil)" ]; then
+        my_ext="pkg,\$my_ext"
+    fi
+    # disable this check for the sake of building the macOS installer on Linux
+    #if [ -n "\$(command -v diskutil)" ]; then
+        # note: could also detect via hdiutil
+        my_ext="dmg,\$my_ext"
+    #fi
+    if [ -n "\$(command -v git)" ]; then
+        my_ext="git,\$my_ext"
+    fi
+    if [ -n "\$(command -v unxz)" ]; then
+        my_ext="xz,\$my_ext"
+    fi
+    if [ -n "\$(command -v unzip)" ]; then
+        my_ext="zip,\$my_ext"
+    fi
+    # for mac/linux 'exe' refers to the uncompressed binary without extension
+    my_ext="exe,\$my_ext"
+    if [ -n "\$(command -v tar)" ]; then
+        my_ext="tar,\$my_ext"
+    fi
+    my_ext="\$(echo "\$my_ext" | sed 's/,$//')" # nix trailing comma
+    set -e
+
+
+    ##
+    ## Detect http client
+    ##
+
+    set +e
+    export WEBI_CURL="\$(command -v curl)"
+    export WEBI_WGET="\$(command -v wget)"
+    set -e
+
+    export WEBI_HOST="\${WEBI_HOST:-https://webinstall.dev}"
+    export WEBI_UA="\$(uname -a)"
+
+
+    function webinstall() {
+
+        my_package="\${1:-}"
+        if [ -z "\$my_package" ]; then
+            >&2 echo "Usage: webi <package>@<version> ..."
+            >&2 echo "Example: webi node@lts rg"
+            exit 1
+        fi
+
+        export WEBI_BOOT="\$(mktemp -d -t "\$my_package-bootstrap.\$WEBI_TIMESTAMP.XXXXXXXX")"
+
+        my_installer_url="\$WEBI_HOST/api/installers/\$my_package.sh?formats=\$my_ext"
+        set +e
+        if [ -n "\$WEBI_CURL" ]; then
+            curl -fsSL "\$my_installer_url" -H "User-Agent: curl \$WEBI_UA" \\
+                -o "\$WEBI_BOOT/\$my_package-bootstrap.sh"
+        else
+            wget -q "\$my_installer_url" --user-agent="wget \$WEBI_UA" \\
+                -O "\$WEBI_BOOT/\$my_package-bootstrap.sh"
+        fi
+        if ! [ \$? -eq 0 ]; then
+          >&2 echo "error fetching '\$my_installer_url'"
+          exit 1
+        fi
+        set -e
+
+        pushd "\$WEBI_BOOT" 2>&1 > /dev/null
+            bash "\$my_package-bootstrap.sh"
+        popd 2>&1 > /dev/null
+
+        rm -rf "\$WEBI_BOOT"
+
+    }
+
+    show_path_updates() {
+
+        if ! [ -n "\${_WEBI_CHILD}" ]; then
+            if [ -f "\$_webi_tmp/.PATH.env" ]; then
+                my_paths=\$(cat "\$_webi_tmp/.PATH.env" | sort -u)
+                if [ -n "\$my_paths" ]; then
+                    echo "IMPORTANT: You must update you PATH to use the installed program(s)"
+                    echo ""
+                    echo "You can either"
+                    echo "A) can CLOSE and REOPEN Terminal or"
+                    echo "B) RUN these exports:"
+                    echo ""
+                    echo "\$my_paths"
+                    echo ""
+                fi
+                rm -f "\$_webi_tmp/.PATH.env"
+            fi
+        fi
+
+    }
+
+    for pkgname in "\$@"
+    do
+        webinstall "\$pkgname"
+    done
+
+    show_path_updates
+
+}
+
+__webi_main "\$@"
+
+EOF
+
+    chmod a+x "$HOME/.local/bin/webi"
+
+    if [ -n "${WEBI_PKG:-}" ]; then
+        "$HOME/.local/bin/webi" "${WEBI_PKG}"
+    else
+        echo ""
+        echo "Hmm... no WEBI_PKG was specified. This is probably an error in the script."
+        echo ""
+        echo "Please open an issue with this information: Package '${WEBI_PKG:-}' on '$(uname -s)/$(uname -m)'"
+        echo "    https://github.com/webinstall/packages/issues"
+        echo ""
+    fi
+
+}
+
+__install_webi

_webi/builds-cacher-test.js

@@ -1,72 +0,0 @@
-'use strict';
-
-let Path = require('node:path');
-
-let BuildsCacher = require('./builds-cacher.js');
-// let Parallel = require('./parallel.js');
-
-var INSTALLERS_DIR = Path.join(__dirname, '..');
-var CACHE_DIR = Path.join(__dirname, '../_cache');
-
-async function main() {
-  let bc = BuildsCacher.create({
-    caches: CACHE_DIR,
-    installers: INSTALLERS_DIR,
-  });
-
-  // let dirs = await bc.getProjectsByType();
-  // let projNames = Object.keys(dirs.valid);
-
-  let lastUpdate;
-
-  let projName = 'k9s';
-  {
-    let packages = await bc.getPackages({
-      //Releases: Releases,
-      name: projName,
-      date: new Date(),
-    });
-    lastUpdate = packages.updated;
-    console.info(
-      `Last update for '${projName}': ${packages.updated} (${packages.releases.length} assets)`,
-    );
-  }
-
-  console.info('Waiting 5s');
-  {
-    setTimeout(async function () {
-      let packages = await bc.getPackages({
-        //Releases: Releases,
-        name: projName,
-        date: new Date(),
-      });
-      console.info(
-        `Last update for '${projName}': ${packages.updated} (${packages.releases.length} assets)`,
-      );
-      if (lastUpdate < packages.updated) {
-        console.info(`PASS`);
-      } else {
-        console.info(`MAYBE fail`);
-      }
-    }, 5 * 1000);
-  }
-
-  //let parallel = 25;
-  //await Parallel.run(parallel, projNames, getAll);
-  //async function getAll(name) {
-  //  void (await bc.getPackages({
-  //    //Releases: Releases,
-  //    name: name,
-  //    date: new Date(),
-  //  }));
-  //}
-}
-
-main()
-  .then(function () {
-    console.log('Done');
-  })
-  .catch(function (e) {
-    console.error(e.stack || e);
-    process.exit(1);
-  });

_webi/builds-cacher.js

@@ -1,907 +0,0 @@
-'use strict';
-
-var BuildsCacher = module.exports;
-
-let Fs = require('node:fs/promises');
-let Os = require('node:os');
-let Path = require('node:path');
-
-let LEGACY_CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-
-let HostTargets = require('./build-classifier/host-targets.js');
-let Lexver = require('./build-classifier/lexver.js');
-let Triplet = require('./build-classifier/triplet.js');
-
-var ALIAS_RE = /^alias: ([\w.-]+)$/m;
-
-var LEGACY_ARCH_MAP = {
-  '*': 'ANYARCH',
-  arm64: 'aarch64',
-  armv6l: 'armv6',
-  armv7l: 'armv7',
-  amd64: 'x86_64',
-  mipsle: 'mipsel',
-  mips64le: 'mips64el',
-  mipsr6le: 'mipsr6el',
-  mips64r6le: 'mips64r6el',
-  // yes... el for arm and mips, but le for ppc
-  // (perhaps the joke got old?)
-  ppc64el: 'ppc64le',
-  386: 'x86',
-};
-var LEGACY_OS_MAP = {
-  '*': 'ANYOS',
-  macos: 'darwin',
-  posix: 'posix_2017',
-};
-
-var TERMS_META = [
-  // pattern
-  '{ARCH}',
-  '{EXT}',
-  '{LIBC}',
-  '{NAME}',
-  '{OS}',
-  '{VENDOR}',
-  // // os-/arch-indepedent
-  // 'ANYARCH',
-  // 'ANYOS',
-  // // libc
-  // 'none',
-  // channel
-  'beta',
-  'dev',
-  'preview',
-  'stable',
-];
-
-/** @typedef {String} TripletString - {arch}-{vendor}-{os}-{libc} */
-/** @typedef {String} VersionString */
-/** @typedef {Object.<VersionString, Array<BuildAsset>>} PackagesByRelease */
-
-/**
- * @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
- * @prop {Array<String>} lexvers
- * @prop {Object.<String, String>} lexversMap
- */
-
-/**
- * @typedef BuildAsset
- * @prop {String} name
- * @prop {String} version
- * @prop {Boolean} lts
- * @prop {String} date
- * @prop {String} arch
- * @prop {String} os
- * @prop {String} libc
- * @prop {String} ext
- * @prop {String} download
- */
-
-/**
- * @typedef VersionTarget
- * @prop {String} version
- * @prop {Boolean} lts
- * @prop {String} channel
- */
-
-/** @typedef {TargetTriplet & HostTargetPartial} HostTarget */
-/** @typedef {import('./build-classifier/types.js').TargetTriplet} TargetTriplet */
-/**
- * @typedef HostTargetPartial
- * @prop {String} target.triplet - os-vendor-arch-libc
- * @prop {Error} target.error
- */
-
-async function getPartialHeader(path) {
-  let readme = `${path}/README.md`;
-  let head = await readFirstBytes(readme).catch(function (err) {
-    if (err.code !== 'ENOENT') {
-      console.warn(`warn: ${path}: ${err.message}`);
-    }
-    return null;
-  });
-
-  return head;
-}
-
-// let fsOpen = util.promisify(Fs.open);
-// let fsRead = util.promisify(Fs.read);
-async function readFirstBytes(path) {
-  let start = 0;
-  let n = 1024;
-  let fh = await Fs.open(path, 'r');
-  let buf = Buffer.alloc(n);
-  let result = await fh.read(buf, start, n);
-  let str = result.buffer.toString('utf8');
-  await fh.close();
-
-  return str;
-}
-
-BuildsCacher.create = function ({ ALL_TERMS, installers }) {
-  let installersDir = installers;
-
-  if (!ALL_TERMS) {
-    ALL_TERMS = Triplet.TERMS_PRIMARY_MAP;
-  }
-
-  let bc = {};
-  bc.ALL_TERMS = ALL_TERMS;
-  bc.orphanTerms = Object.assign({}, bc.ALL_TERMS);
-  bc.unknownTerms = {};
-  bc.usedTerms = {};
-  bc.formats = [];
-  bc._triplets = {};
-  bc._targetsByBuildIdCache = {};
-  bc._caches = {};
-  bc._allFormats = {};
-  bc._allTriplets = {};
-  // Per-name lock: serializes cold-cache getPackages so concurrent
-  // callers can't corrupt bc._caches[name] via a transformAndUpdate race.
-  bc._inflight = {};
-
-  for (let term of TERMS_META) {
-    delete bc.orphanTerms[term];
-  }
-
-  bc.getProjectsByType = async function () {
-    let dirs = {
-      hidden: {},
-      errors: {},
-      alias: {},
-      invalid: {},
-      selfhosted: {},
-      valid: {},
-    };
-
-    let entries = await Fs.readdir(installersDir, { withFileTypes: true });
-    for (let entry of entries) {
-      let meta = await bc.getProjectTypeByEntry(entry);
-      dirs[meta.type][entry.name] = meta.detail;
-    }
-
-    return dirs;
-  };
-
-  /**
-   * Get project type and detail - alias, selfhosted, valid (and the invalids)
-   * @param {String} name - filename
-   */
-  bc.getProjectType = async function (name) {
-    let filepath = Path.join(installersDir, name);
-    let entry;
-    try {
-      entry = await Fs.lstat(filepath);
-      Object.assign(entry, { name: name });
-    } catch (e) {
-      return { type: 'errors', detail: 'not found' };
-    }
-    let info = await bc.getProjectTypeByEntry(entry);
-
-    return info;
-  };
-
-  /**
-   * Get project type and detail - alias, selfhosted, valid (and the invalids)
-   * @param {fs.Stats|fs.Dirent} entry
-   */
-  bc.getProjectTypeByEntry = async function (entry) {
-    let path = Path.join(installersDir, entry.name);
-
-    // skip non-installer dirs
-    if (entry.isSymbolicLink()) {
-      let link = await Fs.readlink(path);
-      return { type: 'alias', detail: link };
-    }
-
-    if (!entry.isDirectory()) {
-      return { type: 'hidden', detail: '!directory' };
-    }
-    if (entry.name === 'node_modules') {
-      return { type: 'hidden', detail: 'node_modules' };
-    }
-    if (entry.name.startsWith('_')) {
-      return { type: 'hidden', detail: '_*' };
-    }
-    if (entry.name.startsWith('.')) {
-      return { type: 'hidden', detail: '.*' };
-    }
-    if (entry.name.startsWith('~')) {
-      return { type: 'hidden', detail: '~*' };
-    }
-    if (entry.name.endsWith('~')) {
-      return { type: 'hidden', detail: '*~' };
-    }
-
-    // skip invalid installers
-    let head = await getPartialHeader(path);
-    if (!head) {
-      return { type: 'invalid', detail: '!README.md' };
-    }
-
-    let alias = head.match(ALIAS_RE);
-    if (alias) {
-      let link = alias[1];
-      return { type: 'alias', detail: link };
-    }
-
-    let cacheFile = `${LEGACY_CACHE_DIR}/${entry.name}.json`;
-    let hasCacheFile = await Fs.access(cacheFile)
-      .then(function () {
-        return true;
-      })
-      .catch(function () {
-        return false;
-      });
-    if (!hasCacheFile) {
-      return { type: 'selfhosted', detail: true };
-    }
-
-    return { type: 'valid', detail: true };
-  };
-
-  // 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 (args) {
-    let name = args.name;
-    let warm = bc._caches[name];
-    if (warm) {
-      return _doGetPackages(args);
-    }
-    let inflight = bc._inflight[name];
-    if (inflight) {
-      return inflight;
-    }
-    let p = _doGetPackages(args).finally(function () {
-      delete bc._inflight[name];
-    });
-    bc._inflight[name] = p;
-    return p;
-  };
-
-  async function _doGetPackages({ name }) {
-    let dataFile = `${LEGACY_CACHE_DIR}/${name}.json`;
-    let tsFile = `${LEGACY_CACHE_DIR}/${name}.updated.txt`;
-
-    let tsDate;
-    {
-      let secondsStr = await Fs.readFile(tsFile, 'ascii').catch(function (err) {
-        if (err.code !== 'ENOENT') {
-          throw err;
-        }
-        return '0';
-      });
-      secondsStr = secondsStr.trim();
-      let seconds = parseFloat(secondsStr) || 0;
-      let ms = seconds * 1000;
-      tsDate = new Date(ms);
-    }
-
-    let projInfo = bc._caches[name];
-
-    let meta = {
-      // version info
-      versions: projInfo?.versions || [],
-      lexvers: projInfo?.lexvers || [],
-      lexversMap: projInfo?.lexversMap || {},
-      // culled release assets
-      packages: projInfo?.packages || [],
-      releasesByTriplet: projInfo?.releasesByTriplet || {},
-      // target info
-      triplets: projInfo?.triplets || [],
-      oses: projInfo?.oses || [],
-      arches: projInfo?.arches || [],
-      libcs: projInfo?.libcs || [],
-      formats: projInfo?.formats || [],
-      // TODO channels: projInfo?.channels || [],
-    };
-
-    if (!projInfo) {
-      let json = await Fs.readFile(dataFile, 'ascii').catch(
-        async function (err) {
-          if (err.code !== 'ENOENT') {
-            throw err;
-          }
-
-          return null;
-        },
-      );
-
-      try {
-        projInfo = JSON.parse(json);
-      } catch (e) {
-        console.error(`error: ${dataFile}:\n\t${e.message}`);
-        projInfo = null;
-      }
-    }
-    if (!projInfo) {
-      return meta;
-    }
-    let latestProjInfo = await BuildsCacher.transformAndUpdate(
-      name,
-      projInfo,
-      meta,
-      tsDate,
-      bc,
-    );
-    bc._caches[name] = latestProjInfo;
-
-    return latestProjInfo;
-  }
-
-  /**
-   * Given a list of acceptable formats, get the sorted list of of formats.
-   * Actually used (as per node _webi/lint-builds.js):
-   *     .7z
-   *     .app.zip
-   *     .dmg
-   *     .exe
-   *     .exe.xz
-   *     .git
-   *     .gz
-   *     .msi
-   *     .pkg
-   *     .pkg.tar.zst
-   *     .sh
-   *     .tar.gz
-   *     .tar.xz
-   *     .xz
-   *     .zip
-   */
-  bc.getSortedFormats = function (formats) {
-    /* jshint maxcomplexity: 25 */
-    formats.sort();
-    let id = formats.join(',');
-    if (bc._allFormats[id]) {
-      return bc._allFormats[id];
-    }
-
-    // we don't know how to handle any of these yet
-    // let exclude = [];
-    // let isAndroid = false;
-    // if (!isAndroid) {
-    //   exclude.push('.apk');
-    // }
-    // let isDebian = false;
-    // if (!isDebian) {
-    //   exclude.push('.deb');
-    // }
-    // let isEnterpriseLinux = false;
-    // if (!isEnterpriseLinux) {
-    //   exclude.push('.rpm');
-    // }
-    // let isArch = false;
-    // if (!isArch) {
-    //   exclude.push('.pkg.tar.zst');
-    // }
-
-    let hasExe = formats.includes('exe') || formats.includes('.exe');
-
-    /** @type {Array<String>} */
-    let exts = [];
-
-    let hasXz = formats.includes('xz') || formats.includes('.xz');
-    if (hasXz) {
-      exts.push('.tar.xz');
-      if (hasExe) {
-        exts.push('.exe.xz');
-      }
-      exts.push('.xz');
-    }
-    let hasZst = formats.includes('zst') || formats.includes('.zst');
-    if (hasZst) {
-      exts.push('.tar.zst');
-      exts.push('.zst');
-    }
-    let hasZip = formats.includes('zip') || formats.includes('.zip');
-    if (hasZip) {
-      exts.push('.zip');
-    }
-    let has7z = false;
-    if (has7z) {
-      exts.push('.7z');
-    }
-    // let hasBz2 = formats.includes('bz2') || formats.includes('.bz2');
-    // if (hasBz2) {
-    // 	exts.push('.bz2');
-    // }
-    if (hasExe) {
-      if (!hasZip) {
-        exts.push('.zip');
-      }
-      exts.push('.tar.gz');
-      exts.push('.gz');
-      exts.push('.exe');
-      exts.push('.msi');
-      //exts.push('.msixbundle');
-    } else {
-      exts.push('.tar.gz');
-      exts.push('.gz');
-      exts.push('.sh');
-    }
-    let hasGit = formats.includes('git') || formats.includes('.git');
-    if (hasGit) {
-      exts.push('.git');
-    }
-
-    // Fallbacks
-    // (we include everything to bubble an extract error over not found)
-    exts.push('.app.zip');
-    exts.push('.dmg');
-    exts.push('.pkg');
-    if (!hasXz) {
-      exts.push('.tar.xz');
-      if (hasExe) {
-        exts.push('.exe.xz');
-      }
-      exts.push('.xz');
-    }
-    if (!hasZip) {
-      if (!hasExe) {
-        exts.push('.zip');
-      }
-    }
-    if (!hasZst) {
-      exts.push('.tar.zst');
-      exts.push('.zst');
-    }
-    if (!has7z) {
-      exts.push('.7z');
-    }
-    // if (!hasRar) {
-    // 	exts.push('.rar');
-    // }
-    // exts.push('.tar.bz2');
-    // exts.push('.bz2');
-
-    bc._allFormats[id] = exts;
-    return exts;
-  };
-
-  bc.selectPackage = function (packages, formats) {
-    if (packages.length === 1) {
-      return packages[0];
-    }
-
-    let exts = bc.getSortedFormats(formats);
-    for (let ext of exts) {
-      for (let build of packages) {
-        if (build.ext === ext) {
-          return build;
-        }
-      }
-    }
-
-    return packages[0];
-  };
-
-  /**
-   * @param {ProjectInfo} projInfo
-   */
-  bc.enumerateLatestVersions = function (projInfo) {
-    let lexPrefix = '';
-    let matchInfo = Lexver.matchSorted(projInfo.lexvers, lexPrefix);
-    let verInfo = {
-      default: projInfo.lexversMap[matchInfo.default],
-      previous: projInfo.lexversMap[matchInfo.previous],
-      stable: projInfo.lexversMap[matchInfo.stable],
-      latest: projInfo.lexversMap[matchInfo.latest],
-    };
-
-    return verInfo;
-  };
-
-  /**
-   * @param {ProjectInfo} projInfo
-   * @param {HostTarget} hostTarget
-   * @param {VersionTarget} verTarget
-   */
-  bc.findMatchingPackages = function (projInfo, hostTarget, verTarget) {
-    let matchInfo = bc._enumerateVersions(projInfo, verTarget.version);
-    let triplets = bc._enumerateTriplets(hostTarget);
-    //console.log('dbg: matchInfo', matchInfo);
-
-    if (matchInfo) {
-      for (let _triplet of triplets) {
-        let targetReleases = projInfo.releasesByTriplet[_triplet];
-        if (!targetReleases) {
-          continue;
-        }
-
-        // Make sure that these releases are the expected version
-        // (ex: jq1.7 => darwin-arm64-libc, jq1.6 => darwin-x86_64-libc)
-        for (let matchver of matchInfo.matches) {
-          let ver = projInfo.lexversMap[matchver] || matchver;
-          let packages = targetReleases[ver];
-          if (!packages) {
-            continue;
-          }
-
-          let match = {
-            triplet: _triplet,
-            packages: packages,
-            latest: projInfo.versions[0],
-            version: ver,
-            versions: matchInfo,
-          };
-          return match;
-        }
-      }
-
-      return null;
-    }
-
-    // Version-first iteration, not triplet-first: take the newest
-    // version even when its only build lives in a fallback triplet
-    // (e.g. serviceman v1.0.1 only exists at posix_2017-ANYARCH-none).
-    for (let lexver of projInfo.lexvers) {
-      let ver = projInfo.lexversMap[lexver] || lexver;
-
-      for (let _triplet of triplets) {
-        let targetReleases = projInfo.releasesByTriplet[_triplet];
-        if (!targetReleases) {
-          continue;
-        }
-
-        let packages = targetReleases[ver];
-        if (!packages) {
-          continue;
-        }
-
-        let pkg = packages[0];
-        if (verTarget.lts) {
-          if (!pkg.lts) {
-            continue;
-          }
-
-          let match = {
-            triplet: _triplet,
-            packages: packages,
-            latest: projInfo.versions[0],
-            version: ver,
-            versions: matchInfo,
-          };
-          return match;
-        }
-
-        let wantChannel = verTarget.channel || 'stable';
-        let isChannel = pkg.channel || 'stable';
-        if (wantChannel === 'stable') {
-          if (isChannel !== 'stable') {
-            continue;
-          }
-        }
-        // latest, beta, alpha, rc, preview
-
-        let match = {
-          triplet: _triplet,
-          packages: packages,
-          latest: projInfo.versions[0],
-          version: ver,
-          versions: matchInfo,
-        };
-        return match;
-      }
-    }
-
-    return null;
-  };
-
-  bc._enumerateTriplets = function (hostTarget) {
-    let id = [hostTarget.os, hostTarget.arch, hostTarget.libc].join(',');
-    let triplets = bc._allTriplets[id] || [];
-    if (triplets.length > 0) {
-      return triplets;
-    }
-
-    // Prefer platform-specific matches over ANYOS/ANYARCH fallbacks.
-    // This ensures e.g. darwin-aarch64-none matches before
-    // ANYOS-ANYARCH-none (.git source URLs from old releases).
-    let oses = [];
-    if (hostTarget.os === 'windows') {
-      oses = ['windows', 'ANYOS'];
-    } else if (hostTarget.os === 'android') {
-      oses = ['android', 'linux', 'posix_2017', 'posix_2024', 'ANYOS'];
-    } else {
-      oses = [hostTarget.os, 'posix_2017', 'posix_2024', 'ANYOS'];
-    }
-
-    let waterfall = HostTargets.WATERFALL[hostTarget.os] || {};
-    let arches = waterfall[hostTarget.arch] ||
-      HostTargets.WATERFALL.ANYOS[hostTarget.arch] || [hostTarget.arch];
-    arches = arches.concat(['ANYARCH']);
-    // termsToTarget omits libc for plain UAs; 'libc' → waterfall ['none','libc',...]
-    let libc = hostTarget.libc || 'libc';
-    let libcs = waterfall[libc] ||
-      HostTargets.WATERFALL.ANYOS[libc] || [libc];
-
-    // Extend the glibc-host waterfall: the table only lists [none, libc]
-    // but Rust projects (bat, rg) and node ship libc='gnu' builds, and
-    // static musl builds also run on glibc hosts.
-    if (libc === 'libc' && !libcs.includes('gnu')) {
-      libcs = ['none', 'gnu', 'musl', 'libc'];
-    }
-
-    for (let os of oses) {
-      for (let arch of arches) {
-        for (let libc of libcs) {
-          let triplet = `${os}-${arch}-${libc}`;
-          triplets.push(triplet);
-        }
-      }
-    }
-    bc._allTriplets[id] = triplets;
-
-    return triplets;
-  };
-
-  bc._enumerateVersions = function (projInfo, ver) {
-    if (!ver) {
-      return null;
-    }
-    let lexPrefix = Lexver.parsePrefix(ver);
-    let matchInfo = Lexver.matchSorted(projInfo.lexvers, lexPrefix);
-
-    return matchInfo;
-  };
-
-  return bc;
-};
-
-BuildsCacher._classify = function (bc, projInfo, build) {
-  /* jshint maxcomplexity: 30 */
-  // Cache entries arrive pre-classified (os/arch/libc/ext set). Skip
-  // maybeInstallable for those — it false-rejects names ending in a
-  // version tag (`serviceman-v1.0.1`, `v1.0.1.zip`).
-  let cacheClassified =
-    build.os && build.arch && build.libc && build.ext;
-  if (!cacheClassified) {
-    let maybeInstallable = Triplet.maybeInstallable(projInfo, build);
-    if (!maybeInstallable) {
-      return null;
-    }
-  }
-
-  if (LEGACY_OS_MAP[build.os]) {
-    build.os = LEGACY_OS_MAP[build.os];
-  }
-  if (LEGACY_ARCH_MAP[build.arch]) {
-    build.arch = LEGACY_ARCH_MAP[build.arch];
-  }
-
-  // because some packages are shimmed to match a single download against
-  let preTarget = Object.assign({ os: '', arch: '', libc: '' }, build);
-
-  let targetId = `${preTarget.os}:${preTarget.arch}:${preTarget.libc}`;
-  let buildId = `${projInfo.name}:${targetId}@${build.download}`;
-  //console.log(`dbg: buildId`, buildId);
-  let target = bc._targetsByBuildIdCache[buildId];
-  if (target) {
-    Object.assign(build, { target: target, triplet: target.triplet });
-    return target;
-  }
-
-  let pattern = Triplet.toPattern(projInfo, build);
-  //console.log(`dbg: pattern`, pattern);
-  if (!pattern) {
-    let err = new Error(`no pattern generated for ${projInfo.name}`);
-    err.code = 'E_BUILD_NO_PATTERN';
-    target = { error: err };
-    bc._targetsByBuildIdCache[buildId] = target;
-    return target;
-  }
-
-  let rawTerms = pattern.split(/[_\{\}\/\.\-]+/g);
-  //console.log(`dbg: rawTerms`, rawTerms);
-  for (let term of rawTerms) {
-    delete bc.orphanTerms[term];
-    bc.usedTerms[term] = true;
-  }
-
-  // {NAME}/{NAME}-{VER}-Windows-x86_64_v2-musl.exe =>
-  //     {NAME}.windows.x86_64v2.musl.exe
-  let terms = Triplet.patternToTerms(pattern);
-  //console.log(`dbg: terms`, terms);
-  if (!terms.length) {
-    let err = new Error(`'${terms}' was trimmed to ''`);
-    target = { error: err };
-    bc._targetsByBuildIdCache[buildId] = target;
-    return target;
-  }
-
-  for (let term of terms) {
-    if (!term) {
-      continue;
-    }
-
-    if (bc.ALL_TERMS[term]) {
-      delete bc.orphanTerms[term];
-      bc.usedTerms[term] = true;
-      continue;
-    }
-
-    bc.unknownTerms[term] = true;
-  }
-
-  // Skip termsToTarget for cache-classified entries: it false-flags
-  // e.g. .git URLs as os=ANYOS while the cache says os=posix_2017,
-  // and the mismatch check throws.
-  target = { triplet: '' };
-  if (cacheClassified) {
-    target.os = build.os;
-    target.arch = build.arch;
-    target.libc = build.libc;
-    target.vendor = build.vendor || 'unknown';
-    target.android = false;
-    target.unknownTerms = [];
-  } else {
-    try {
-      void Triplet.termsToTarget(target, projInfo, build, terms);
-    } catch (e) {
-      console.error(`PACKAGE FORMAT CHANGE for '${projInfo.name}':`);
-      console.error(e.message);
-      console.error(build);
-      return null;
-    }
-  }
-
-  target.triplet = `${target.arch}-${target.vendor}-${target.os}-${target.libc}`;
-
-  {
-    // TODO I don't love this hidden behavior
-    // perhaps classify should just happen when the package is loaded
-    // (and the sanity error should be removed, or thrown after the loop is complete)
-    let hasTriplet = projInfo.triplets.includes(target.triplet);
-    if (!hasTriplet) {
-      projInfo.triplets.push(target.triplet);
-    }
-    let hasOs = projInfo.oses.includes(target.os);
-    if (!hasOs) {
-      projInfo.oses.push(target.os);
-    }
-    let hasArch = projInfo.arches.includes(target.arch);
-    if (!hasArch) {
-      projInfo.arches.push(target.arch);
-    }
-    let hasLibc = projInfo.libcs.includes(target.libc);
-    if (!hasLibc) {
-      projInfo.libcs.push(target.libc);
-    }
-
-    if (!build.ext) {
-      build.ext = Triplet.buildToPackageType(build);
-    }
-    if (build.ext) {
-      if (!build.ext.startsWith('.')) {
-        build.ext = `.${build.ext}`;
-      }
-    }
-    let hasExt = projInfo.formats.includes(build.ext);
-    if (!hasExt) {
-      projInfo.formats.push(build.ext);
-    }
-    let hasGlobalExt = bc.formats.includes(build.ext);
-    if (!hasGlobalExt) {
-      bc.formats.push(build.ext);
-    }
-  }
-
-  bc._triplets[target.triplet] = true;
-  bc._targetsByBuildIdCache[buildId] = target;
-
-  let triple = [target.arch, target.vendor, target.os, target.libc];
-  for (let term of triple) {
-    if (!bc.ALL_TERMS[term]) {
-      throw new Error(
-        `[SANITY FAIL] '${projInfo.name}' '${target.triplet}' generated unknown term '${term}'`,
-      );
-    }
-
-    delete bc.orphanTerms[term];
-    bc.usedTerms[term] = true;
-  }
-
-  return target;
-};
-
-BuildsCacher.transformAndUpdate = function (name, projInfo, meta, date, bc) {
-  meta.packages = [];
-
-  let updated = date.valueOf();
-
-  Object.assign(projInfo, { name, updated }, meta);
-  for (let build of projInfo.releases) {
-    let buildTarget = BuildsCacher._classify(bc, projInfo, build);
-    if (!buildTarget) {
-      // ignore known, non-package extensions
-      continue;
-    }
-
-    if (buildTarget.error) {
-      let err = buildTarget.error;
-      let code = err.code || '';
-      console.error(`[ERROR]: ${code} ${projInfo.name}: ${build.name}`);
-      console.error(`>>> ${err.message} <<<`);
-      console.error(projInfo);
-      console.error(build);
-      console.error(`^^^ ${err.message} ^^^`);
-      console.error(err.stack);
-      continue;
-    }
-
-    if (!build.name) {
-      build.name = build.download.replace(/.*\//, '');
-    }
-
-    build.target = buildTarget;
-    meta.packages.push(build);
-  }
-
-  BuildsCacher.updateReleasesByTriplet(meta);
-  BuildsCacher.updateAndSortVersions(projInfo, meta);
-
-  Object.assign(projInfo, { name, updated }, meta);
-  return projInfo;
-};
-
-// TODO
-//   - tag channels
-BuildsCacher.updateAndSortVersions = function (projInfo, meta) {
-  for (let build of projInfo.packages) {
-    let hasVersion = meta.versions.includes(build.version);
-    if (!hasVersion) {
-      build.lexver = Lexver.parseVersion(build.version);
-      meta.lexversMap[build.lexver] = build.version;
-    }
-  }
-
-  meta.lexvers = Object.keys(meta.lexversMap);
-  meta.lexvers.sort();
-  meta.lexvers.reverse();
-
-  meta.versions = [];
-  for (let lexver of meta.lexvers) {
-    let version = meta.lexversMap[lexver];
-    meta.versions.push(version);
-  }
-
-  projInfo.packages.sort(function (a, b) {
-    if (a.lexver > b.lexver) {
-      return -1;
-    }
-    if (a.lexver < b.lexver) {
-      return 1;
-    }
-    return 0;
-  });
-};
-
-BuildsCacher.updateReleasesByTriplet = function (meta) {
-  for (let build of meta.packages) {
-    let target = build.target;
-
-    let triplet = `${target.os}-${target.arch}-${target.libc}`;
-    if (!meta.releasesByTriplet[triplet]) {
-      meta.releasesByTriplet[triplet] = {};
-    }
-
-    let buildsByRelease = meta.releasesByTriplet[triplet];
-    if (!buildsByRelease[build.version]) {
-      buildsByRelease[build.version] = [];
-    }
-
-    let packages = buildsByRelease[build.version];
-    packages.push(build);
-  }
-};

_webi/builds.js

@@ -1,37 +0,0 @@
-'use strict';
-
-let Builds = module.exports;
-
-let Path = require('node:path');
-
-let BuildsCacher = require('./builds-cacher.js');
-// let HostTargets = require('./build-classifier/host-targets.js');
-let Parallel = require('./parallel.js');
-
-var INSTALLERS_DIR = Path.join(__dirname, '..');
-var CACHE_DIR = Path.join(__dirname, '../_cache');
-
-let bc = BuildsCacher.create({
-  caches: CACHE_DIR,
-  installers: INSTALLERS_DIR,
-});
-
-Builds.init = async function () {
-  let dirs = await bc.getProjectsByType();
-  let projNames = Object.keys(dirs.valid);
-
-  let parallel = 25;
-  await Parallel.run(parallel, projNames, getAll);
-  async function getAll(name) {
-    void (await bc.getPackages({
-      name: name,
-      date: new Date(),
-    }));
-  }
-};
-
-Builds.enumerateLatestVersions = bc.enumerateLatestVersions;
-Builds.findMatchingPackages = bc.findMatchingPackages;
-Builds.getPackage = bc.getPackages;
-Builds.getProjectType = bc.getProjectType;
-Builds.selectPackage = bc.selectPackage;

_webi/classify-one.js

@@ -1,90 +0,0 @@
-'use strict';
-
-let Fs = require('node:fs/promises');
-let Os = require('node:os');
-let Path = require('node:path');
-
-let BuildsCacher = require('./builds-cacher.js');
-let Triplet = require('./build-classifier/triplet.js');
-
-let LEGACY_CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-
-async function main() {
-  let projName = process.argv[2];
-  if (!projName) {
-    console.error(``);
-    console.error(`USAGE`);
-    console.error(``);
-    console.error(`    classify-one <project-name>`);
-    console.error(``);
-    console.error(`EXAMPLE`);
-    console.error(``);
-    console.error(`    classify-one caddy`);
-    console.error(``);
-    return;
-  }
-
-  let tsDate = new Date(0);
-  let meta = {
-    // version info
-    versions: [],
-    lexvers: [],
-    lexversMap: {},
-    // culled release assets
-    packages: [],
-    releasesByTriplet: {},
-    // target info
-    triplets: [],
-    oses: [],
-    arches: [],
-    libcs: [],
-    formats: [],
-  };
-
-  let dataFile = Path.join(LEGACY_CACHE_DIR, `${projName}.json`);
-  let json = await Fs.readFile(dataFile, 'utf8');
-  let projInfo = JSON.parse(json);
-
-  // let packages = await Builds.getPackage({ name: projName });
-  // console.log(packages);
-
-  let bc = {};
-  bc.ALL_TERMS = Triplet.TERMS_PRIMARY_MAP;
-  bc.orphanTerms = Object.assign({}, bc.ALL_TERMS);
-  bc.unknownTerms = {};
-  bc.usedTerms = {};
-  bc.formats = [];
-  bc._targetsByBuildIdCache = {};
-  bc._triplets = {};
-
-  let transformed = BuildsCacher.transformAndUpdate(
-    projName,
-    projInfo,
-    meta,
-    tsDate,
-    bc,
-  );
-
-  console.log(`[DEBUG] transformed`);
-  let sample = transformed.packages.slice(0, 20);
-  console.log('packages:', sample, ':packages');
-  let firstTriplet = Object.keys(transformed.releasesByTriplet)[0];
-  let firstVersion = transformed.versions[0];
-  console.log(
-    `releasesByTriplet[${firstTriplet}][${firstVersion}]:`,
-    transformed.releasesByTriplet[firstTriplet]?.[firstVersion],
-    ':releasesByTriplet',
-  );
-  console.log('versions:', transformed.versions, ':versions');
-  console.log('triplets:', transformed.triplets, ':triplets');
-  console.log('oses:', transformed.oses, ':oses');
-  console.log('arches:', transformed.arches, ':arches');
-  console.log('libcs:', transformed.libcs, ':libcs');
-  console.log('formats:', transformed.formats, ':formats');
-  console.log(Object.keys(transformed));
-}
-
-main().catch(function (err) {
-  console.error('Error:');
-  console.error(err);
-});

_webi/curl-pipe-bootstrap.tpl.ps1

@@ -1,12 +0,0 @@
-# Download the latest webi, then install {{ exename }}
-# <pre>
-############################################################
-# <h1>Cheat Sheet at CHEATSHEET_URL</h1>
-# <meta http-equiv="refresh" content="3; URL='CHEATSHEET_URL'" />
-############################################################
-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"
-Set-ExecutionPolicy -Scope Process Bypass
-& "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" "{{ exename }}"

_webi/curl-pipe-bootstrap.tpl.sh

@@ -1,349 +0,0 @@
-#!/bin/sh
-#<pre>
-
-############################################################
-# <h1>Cheat Sheet at CHEATSHEET_URL</h1>
-# <meta http-equiv="refresh" content="3; URL='CHEATSHEET_URL'" />
-############################################################
-
-export WEBI_PKG=webi
-export WEBI_HOST=https://webinstall.dev
-export WEBI_CHECKSUM=06a7fb9f
-
-#########################################
-#                                       #
-# Display Debug Info in Case of Failure #
-#                                       #
-#########################################
-
-fn_show_welcome() { (
-    echo ""
-    echo ""
-    # invert t_task and t_pkg for top-level welcome message
-    printf -- ">>> %s %s  <<<\n" \
-        "$(t_pkg 'Welcome to') $(t_task 'Webi')$(t_pkg '!')" \
-        "$(t_dim "- modern tools, instant installs.")"
-    echo "    We expect your experience to be $(t_em 'absolutely perfect')!"
-    echo ""
-    echo "    $(t_attn 'Success')? Star it!   $(t_url 'https://github.com/webinstall/webi-installers')"
-    echo "    $(t_attn 'Problem')? Report it: $(t_url 'https://github.com/webinstall/webi-installers/issues')"
-    echo "                        $(t_dim "(your system is") $(t_host "$(fn_get_os)")/$(t_host "$(uname -m)") $(t_dim "with") $(t_host "$(fn_get_libc)") $(t_dim "&") $(t_host "$(fn_get_http_client_name)")$(t_dim ")")"
-
-    sleep 0.2
-); }
-
-fn_get_os() { (
-    # Ex:
-    #     GNU/Linux
-    #     Android
-    #     Linux (often Alpine, musl)
-    #     Darwin
-    b_os="$(uname -o 2> /dev/null || echo '')"
-    b_sys="$(uname -s)"
-    if test -z "${b_os}" || test "${b_os}" = "${b_sys}"; then
-        # ex: 'Darwin' (and plain, non-GNU 'Linux')
-        echo "${b_sys}"
-        return 0
-    fi
-
-    if echo "${b_os}" | grep -q "${b_sys}"; then
-        # ex: 'GNU/Linux'
-        echo "${b_os}"
-        return 0
-    fi
-
-    # ex: 'Android/Linux'
-    echo "${b_os}/${b_sys}"
-); }
-
-fn_get_libc() { (
-    # Ex:
-    #     musl
-    #     libc
-    if ldd /bin/ls 2> /dev/null | grep -q 'musl' 2> /dev/null; then
-        echo 'musl'
-    elif fn_get_os | grep -q 'GNU|Linux'; then
-        echo 'gnu'
-    else
-        echo 'libc'
-    fi
-); }
-
-fn_get_http_client_name() { (
-    # Ex:
-    #     curl
-    #     curl+wget
-    b_client=""
-    if command -v curl > /dev/null; then
-        b_client="curl"
-    fi
-    if command -v wget > /dev/null; then
-        if test -z "${b_client}"; then
-            b_client="wget"
-        else
-            b_client="curl+wget"
-        fi
-    fi
-
-    echo "${b_client}"
-); }
-
-#########################################
-#                                       #
-#      For Making the Display Nice      #
-#                                       #
-#########################################
-
-# Term Types
-t_cmd() { (fn_printf '\e[2m\e[35m%s\e[39m\e[22m' "${1}"); }
-t_host() { (fn_printf '\e[2m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_link() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_path() { (fn_printf '\e[2m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_pkg() { (fn_printf '\e[1m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_task() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_url() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-
-# Levels
-t_info() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_attn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_warn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_err() { (fn_printf '\e[31m%s\e[39m' "${1}"); }
-
-# Styles
-t_bold() { (fn_printf '\e[1m%s\e[22m' "${1}"); }
-t_dim() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-t_em() { (fn_printf '\e[3m%s\e[23m' "${1}"); }
-t_under() { (fn_printf '\e[4m%s\e[24m' "${1}"); }
-
-# FG Colors
-t_cyan() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_green() { (fn_printf '\e[32m%s\e[39m' "${1}"); }
-t_magenta() { (fn_printf '\e[35m%s\e[39m' "${1}"); }
-t_yellow() { (fn_printf '\e[33m%s\e[39m' "${1}"); }
-
-fn_printf() { (
-    a_style="${1}"
-    a_text="${2}"
-    if fn_is_tty; then
-        #shellcheck disable=SC2059
-        printf -- "${a_style}" "${a_text}"
-    else
-        printf -- '%s' "${a_text}"
-    fi
-); }
-
-fn_sub_home() { (
-    my_rel=${HOME}
-    my_abs=${1}
-    echo "${my_abs}" | sed "s:^${my_rel}:~:"
-); }
-
-###################################
-#                                 #
-#       Detect HTTP Client        #
-#                                 #
-###################################
-
-fn_wget() { (
-    # Doc:
-    #     Downloads the file at the given url to the given path
-    a_url="${1}"
-    a_path="${2}"
-
-    cmd_wget="wget -c -q --user-agent"
-    if fn_is_tty; then
-        cmd_wget="wget -c -q --show-progress --user-agent"
-    fi
-    # busybox wget doesn't support --show-progress
-    # See <https://github.com/webinstall/webi-installers/pull/772>
-    if readlink "$(command -v wget)" | grep -q busybox; then
-        cmd_wget="wget --user-agent"
-    fi
-
-    b_triple_ua="$(fn_get_target_triple_user_agent)"
-    b_agent="webi/wget ${b_triple_ua}"
-    if command -v curl > /dev/null; then
-        b_agent="webi/wget+curl ${b_triple_ua}"
-    fi
-
-    if ! $cmd_wget "${b_agent}" "${a_url}" -O "${a_path}"; then
-        echo >&2 "    $(t_err "failed to download (wget)") '$(t_url "${a_url}")'"
-        echo >&2 "    $cmd_wget '${b_agent}' '${a_url}' -O '${a_path}'"
-        echo >&2 "    $(wget -V)"
-        return 1
-    fi
-); }
-
-fn_curl() { (
-    # Doc:
-    #     Downloads the file at the given url to the given path
-    a_url="${1}"
-    a_path="${2}"
-
-    cmd_curl="curl -f -sSL -#"
-    if fn_is_tty; then
-        cmd_curl="curl -f -sSL"
-    fi
-
-    b_triple_ua="$(fn_get_target_triple_user_agent)"
-    b_agent="webi/curl ${b_triple_ua}"
-    if command -v wget > /dev/null; then
-        b_agent="webi/curl+wget ${b_triple_ua}"
-    fi
-
-    if ! $cmd_curl -A "${b_agent}" "${a_url}" -o "${a_path}"; then
-        echo >&2 "    $(t_err "failed to download (curl)") '$(t_url "${a_url}")'"
-        echo >&2 "    $cmd_curl -A '${b_agent}' '${a_url}' -o '${a_path}'"
-        echo >&2 "    $(curl -V)"
-        return 1
-    fi
-); }
-
-fn_get_target_triple_user_agent() { (
-    # Ex:
-    #     x86_64/unknown GNU/Linux/5.15.107-2-pve gnu
-    #     arm64/unknown Darwin/22.6.0 libc
-    echo "$(uname -m)/unknown $(fn_get_os)/$(uname -r) $(fn_get_libc)"
-); }
-
-fn_download_to_path() { (
-    a_url="${1}"
-    a_path="${2}"
-
-    mkdir -p "$(dirname "${a_path}")"
-    if command -v curl > /dev/null; then
-        fn_curl "${a_url}" "${a_path}.part"
-    elif command -v wget > /dev/null; then
-        fn_wget "${a_url}" "${a_path}.part"
-    else
-        echo >&2 "    $(t_err "failed to detect HTTP client (curl, wget)")"
-        return 1
-    fi
-    mv "${a_path}.part" "${a_path}"
-); }
-
-##############################################
-#                                            #
-# Install or Update Webi and Install Package #
-#                                            #
-##############################################
-
-webi_bootstrap() { (
-    a_path="${1}"
-
-    echo ""
-    echo "$(t_task 'Bootstrapping') $(t_pkg 'Webi')"
-
-    b_path_rel="$(fn_sub_home "${a_path}")"
-    b_checksum=""
-    if test -r "${a_path}"; then
-        b_checksum="$(fn_checksum "${a_path}")"
-    fi
-    if test "$b_checksum" = "${WEBI_CHECKSUM}"; then
-        echo "    $(t_dim 'Found') $(t_path "${b_path_rel}")"
-        sleep 0.1
-        return 0
-    fi
-
-    b_webi_file_url="${WEBI_HOST}/packages/webi/webi.sh"
-    b_tmp=''
-    if test -r "${a_path}"; then
-        b_ts="$(date -u '+%s')"
-        b_tmp="${a_path}.${b_ts}.bak"
-        mv "${a_path}" "${b_tmp}"
-        echo "    Updating $(t_path "${b_path_rel}")"
-    fi
-
-    echo "    Downloading $(t_url "${b_webi_file_url}")"
-    echo "        to $(t_path "${b_path_rel}")"
-    fn_download_to_path "${b_webi_file_url}" "${a_path}"
-    chmod u+x "${a_path}"
-
-    if test -r "${b_tmp}"; then
-        rm -f "${b_tmp}"
-    fi
-); }
-
-fn_checksum() {
-    a_filepath="${1}"
-
-    if command -v sha1sum > /dev/null; then
-        sha1sum "${a_filepath}" | cut -d' ' -f1 | cut -c 1-8
-        return 0
-    fi
-
-    if command -v shasum > /dev/null; then
-        shasum "${a_filepath}" | cut -d' ' -f1 | cut -c 1-8
-        return 0
-    fi
-
-    if command -v sha1 > /dev/null; then
-        sha1 "${a_filepath}" | cut -d'=' -f2 | cut -c 2-9
-        return 0
-    fi
-
-    echo >&2 "    warn: no sha1 sum program"
-    date '+%F %H:%M'
-}
-
-##############################################
-#                                            #
-#          Detect TTY and run main           #
-#                                            #
-##############################################
-
-fn_is_tty() {
-    if test "${WEBI_TTY}" = 'tty'; then
-        return 0
-    fi
-    return 1
-}
-
-fn_detect_tty() { (
-    # stdin will NOT be a tty if it's being piped
-    # stdout & stderr WILL be a tty even when piped
-    # they are not a tty if being captured or redirected
-    # 'set -i' is NOT available in sh
-    if test -t 1 && test -t 2; then
-        return 0
-    fi
-
-    return 1
-); }
-
-main() { (
-    set -e
-    set -u
-
-    WEBI_TTY="${WEBI_TTY:-}"
-    if test -z "${WEBI_TTY}"; then
-        if fn_detect_tty; then
-            WEBI_TTY="tty"
-        fi
-        export WEBI_TTY
-    fi
-
-    if test -z "${WEBI_WELCOME:-}"; then
-        fn_show_welcome
-    fi
-    export WEBI_WELCOME='shown'
-
-    # note: we may support custom locations in the future
-    export WEBI_HOME="${HOME}/.local"
-    b_home="$(fn_sub_home "${WEBI_HOME}")"
-    b_webi_path="${WEBI_HOME}/bin/webi"
-    b_webi_path_rel="${b_home}/bin/webi"
-
-    WEBI_CURRENT="${WEBI_CURRENT:-}"
-    if test "${WEBI_CURRENT}" != "${WEBI_CHECKSUM}"; then
-        webi_bootstrap "${b_webi_path}"
-        export WEBI_CURRENT="${WEBI_CHECKSUM}"
-    fi
-
-    echo "    Running $(t_cmd "${b_webi_path_rel} ${WEBI_PKG}")"
-    echo ""
-
-    "${b_webi_path}" "${WEBI_PKG}"
-); }
-
-main

_webi/example_install_safe_copy.sh

@@ -0,0 +1,14 @@
+# For installing from the extracted package tmp directory
+pkg_install() {
+    pushd "$WEBI_TMP" 2>&1 > /dev/null
+
+    if [ -n "$(command -v rsync 2> /dev/null | grep rsync)" ]; then
+        rsync -Krl ./xmpl*/ "$pkg_src/" 2> /dev/null
+    else
+        cp -Hr ./xmpl*/* "$pkg_src/" 2> /dev/null
+        cp -Hr ./xmpl*/.* "$pkg_src/" 2> /dev/null
+    fi
+    rm -rf ./xmpl*
+
+    popd 2>&1 > /dev/null
+}

_webi/frontmarker.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var fs = require('fs');
-var marked = require('marked').marked;
+var marked = require('marked');
 
 var frontmatter = '---';
 var keyValRe = /(\w+): (.*)/;
@@ -12,6 +12,7 @@ function parseYamlish(txt) {
   var block = false;
 
   var lines = txt.trim().split('\n');
+  var moreRe = /\s+/;
   var last;
 
   if (frontmatter !== lines.shift()) {
@@ -19,7 +20,7 @@ function parseYamlish(txt) {
   }
 
   function unblock() {
-    cfg[block] = marked.parse(cfg[block]);
+    cfg[block] = marked(cfg[block]);
     block = false;
   }
 
@@ -57,7 +58,7 @@ function parseYamlish(txt) {
     var m = line.match(keyValRe);
     if (!m) {
       throw new Error(
-        'invalid key format for: ' + JSON.stringify(line) + ' ' + i,
+        'invalid key format for: ' + JSON.stringify(line) + ' ' + i
       );
     }
     if ('|' === m[2]) {
@@ -68,9 +69,9 @@ function parseYamlish(txt) {
   });
 
   if (block) {
-    cfg[block] = marked.parse(cfg[block]);
+    cfg[block] = marked(cfg[block]);
   }
-  cfg.examples = marked.parse(lines.slice(last).join('\n'));
+  cfg.examples = marked(lines.slice(last).join('\n'));
 
   return cfg;
 }
@@ -79,6 +80,8 @@ module.exports.parse = parseYamlish;
 
 if (require.main === module) {
   console.info(
-    parseYamlish(fs.readFileSync(__dirname + '/../node/README.md', 'utf8')),
+    parseYamlish(
+      fs.readFileSync(__dirname + '/../node/README.md', 'utf8')
+    )
   );
 }

_webi/installers.js

@@ -1,233 +0,0 @@
-'use strict';
-
-var Installers = module.exports;
-
-var Crypto = require('crypto');
-var Fs = require('node:fs/promises');
-var path = require('node:path');
-
-var reInstallTpl = /\s*#?\s*{{ installer }}/;
-
-function padScript(txt) {
-  return txt.replace(/^/g, '        ');
-}
-
-var BAD_SH_RE = /[<>'"`$\\]/;
-Installers.renderBash = async function (
-  pkgdir,
-  rel,
-  { baseurl, pkg, tag, ver, os = '', arch = '', libc = '', formats },
-) {
-  if (!Array.isArray(formats)) {
-    formats = [];
-  }
-  if (!tag) {
-    tag = '';
-  }
-  let installTxt = await Fs.readFile(path.join(pkgdir, 'install.sh'), 'utf8');
-  installTxt = padScript(installTxt);
-  var vers = rel.version.split('.');
-  var v = {
-    major: vers.shift() || '',
-    minor: vers.shift() || '',
-    patch: vers.join('.').replace(/[+\-].*/, ''),
-    build: vers
-      .join('.')
-      .replace(/[^+\-]*/, '')
-      .replace(/^-/, ''),
-  };
-  var pkgFile = rel.filename || rel.name;
-  let tplTxt = await Fs.readFile(
-    path.join(__dirname, 'package-install.tpl.sh'),
-    'utf8',
-  );
-  // ex: 'node@lts' or 'node'
-  var webiPkg = pkg;
-  if (ver) {
-    webiPkg += `@${ver}`;
-  }
-
-  let releaseParams = new URLSearchParams({
-    os: rel.os,
-    arch: rel.arch,
-    libc: rel.libc,
-    formats: formats.join(','),
-    pretty: true,
-  });
-  let releaseSearch = releaseParams.toString();
-  releaseSearch = releaseSearch.replace(/%2C/g, ',');
-  let releaseUrl = `/api/releases/${pkg}@${tag}.tab?${releaseSearch}`;
-  let releaseCsv = [
-    rel.version,
-    rel.lts,
-    rel.channel,
-    rel.date,
-    rel.os,
-    rel.arch,
-    rel.ext,
-    '-',
-    rel.download,
-    rel.name,
-    rel.comment || '',
-  ]
-    .join(',')
-    .replace(/'/g, '');
-
-  let webiChecksum = await Installers.getWebiShChecksum();
-  let envReplacements = [
-    ['WEBI_CHECKSUM', webiChecksum],
-    ['WEBI_PKG', webiPkg],
-    ['WEBI_HOST', baseurl],
-    ['WEBI_OS', os],
-    ['WEBI_ARCH', arch],
-    ['WEBI_LIBC', libc],
-    ['WEBI_TAG', tag],
-    ['WEBI_RELEASES', `${baseurl}${releaseUrl}`],
-    ['WEBI_CSV', releaseCsv],
-    ['WEBI_VERSION', rel.version],
-    ['WEBI_MAJOR', v.major],
-    ['WEBI_MINOR', v.minor],
-    ['WEBI_PATCH', v.patch],
-    ['WEBI_BUILD', v.build],
-    ['WEBI_GIT_BRANCH', rel.git_branch || rel.git_tag],
-    ['WEBI_GIT_TAG', rel.git_tag], // TODO replace with branch
-    ['WEBI_LTS', rel.lts],
-    ['WEBI_CHANNEL', rel.channel],
-    ['WEBI_EXT', rel.ext],
-    ['WEBI_FORMATS', formats.join(',')],
-    ['WEBI_PKG_URL', rel.download],
-    ['WEBI_PKG_PATHNAME', pkgFile],
-    ['WEBI_PKG_FILE', pkgFile], // TODO replace with pathname
-    ['PKG_NAME', pkg],
-    ['PKG_STABLE', rel.stable],
-    ['PKG_LATEST', rel.latest],
-    ['PKG_OSES', (rel.oses || []).join(' ')],
-    ['PKG_ARCHES', (rel.arches || []).join(' ')],
-    ['PKG_LIBCS', (rel.libcs || []).join(' ')],
-    ['PKG_FORMATS', (rel.formats || []).join(' ')],
-  ];
-
-  for (let env of envReplacements) {
-    let name = env[0];
-    let value = env[1];
-    // Ex:
-    // #export WEBI_FOO=xyz => export WEBI_FOO='123'
-    // export WEBI_FOO=     => export WEBI_FOO='123'
-    let envRe = new RegExp(
-      `^[ \\t]*#?[ \\t]*(export[ \\t])?[ \\t]*(${name})=.*`,
-      'm',
-    );
-    if (BAD_SH_RE.test(value)) {
-      throw new Error(`key '${name}' has invalid value '${value}'`);
-    }
-    tplTxt = tplTxt.replace(envRe, `$1$2='${value}'`);
-  }
-
-  tplTxt = tplTxt
-    .replace(/CHEATSHEET_URL/g, `${baseurl}/${pkg}`)
-    // $', $0, ... $9, $`, $&, and $_ all have special meaning
-    // (see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
-    // However, it can be escaped with $$ (which must be escaped with $$)
-    .replace(reInstallTpl, '\n' + installTxt.replace(/\$/g, '$$$$'));
-  return tplTxt;
-};
-
-Installers.renderPowerShell = async function (
-  pkgdir,
-  rel,
-  { baseurl, pkg, tag, ver, os, arch, libc = '', formats },
-) {
-  if (!Array.isArray(formats)) {
-    formats = [];
-  }
-  if (!tag) {
-    tag = '';
-  }
-  let installTxt = await Fs.readFile(path.join(pkgdir, 'install.ps1'), 'utf8');
-  installTxt = padScript(installTxt);
-  /*
-    var vers = rel.version.split('.');
-    var v = {
-      major: vers.shift() || '',
-      minor: vers.shift() || '',
-      patch: vers.join('.').replace(/[+\-].*$/, ''),
-      build: vers
-        .join('.')
-        .replace(/[^+\-]*()/, '')
-        .replace(/^-/, '')
-    };
-  */
-  let tplTxt = await Fs.readFile(
-    path.join(__dirname, 'package-install.tpl.ps1'),
-    'utf8',
-  );
-  var pkgver = pkg + '@' + ver;
-  return (
-    tplTxt
-      .replace(
-        /^(#)?\$Env:WEBI_LIBC\s*=.*/im,
-        "$Env:WEBI_LIBC = '" + libc + "'",
-      )
-      .replace(
-        /^(#)?\$Env:WEBI_HOST\s*=.*/im,
-        "$Env:WEBI_HOST = '" + baseurl + "'",
-      )
-      .replace(
-        /^(#)?\$Env:WEBI_PKG\s*=.*/im,
-        "$Env:WEBI_PKG = '" + pkgver + "'",
-      )
-      .replace(/^(#)?\$Env:PKG_NAME\s*=.*/im, "$Env:PKG_NAME = '" + pkg + "'")
-      .replace(
-        /^(#)?\$Env:WEBI_VERSION\s*=.*/im,
-        "$Env:WEBI_VERSION = '" + rel.version + "'",
-      )
-      .replace(
-        /^(#)?\$Env:WEBI_GIT_TAG\s*=.*/im,
-        "$Env:WEBI_GIT_TAG = '" + rel.git_tag + "'",
-      )
-      .replace(
-        /^(#)?\$Env:WEBI_PKG_URL\s*=.*/im,
-        "$Env:WEBI_PKG_URL = '" + rel.download + "'",
-      )
-      // TODO replace WEBI_PKG_FILE (which is sometimes a dir)
-      .replace(
-        /^(#)?\$Env:WEBI_PKG_PATHNAME\s*=.*/im,
-        "$Env:WEBI_PKG_PATHNAME = '" + rel.name + "'",
-      )
-      // TODO deprecate
-      .replace(
-        /^(#)?\$Env:WEBI_PKG_FILE\s*=.*/im,
-        "$Env:WEBI_PKG_FILE = '" + rel.name + "'",
-      )
-      .replace(reInstallTpl, '\n' + installTxt)
-  );
-};
-
-var _webiShMeta = {
-  stale: 10 * 1000,
-  updated_at: 0,
-  checksum: '',
-  mtime: 0,
-};
-Installers.getWebiShChecksum = async function () {
-  let now = Date.now();
-  let ago = now - _webiShMeta.updated_at;
-  if (ago <= _webiShMeta.stale) {
-    return _webiShMeta.checksum;
-  }
-
-  let webiPath = path.join(__dirname, '../webi/webi.sh');
-  let stat = await Fs.stat(webiPath);
-  if (stat.mtimeMs === _webiShMeta.mtime) {
-    return _webiShMeta.checksum;
-  }
-
-  let webiBuf = await Fs.readFile(webiPath, null);
-  let webiHash = Crypto.createHash('sha1').update(webiBuf).digest('hex');
-  let webiChecksum = webiHash.slice(0, 8);
-
-  _webiShMeta.mtime = stat.mtimeMs;
-  _webiShMeta.updated_at = now;
-  _webiShMeta.checksum = webiChecksum;
-  return _webiShMeta.checksum;
-};

_webi/lint-builds.js

@@ -1,336 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-let Fs = require('node:fs/promises');
-let Path = require('node:path');
-
-let BuildsCacher = require('./builds-cacher.js');
-let HostTargets = require('./build-classifier/host-targets.js');
-let Parallel = require('./parallel.js');
-
-var INSTALLERS_DIR = Path.join(__dirname, '..');
-var CACHE_DIR = Path.join(__dirname, '../_cache');
-
-let UserAgentsMap = require('./build-classifier/uas.json');
-let uas = Object.keys(UserAgentsMap);
-let uaTargetsMap = {};
-for (let ua of uas) {
-  let terms = ua.split(/[\s\/]+/g);
-  let target = {};
-  void HostTargets.termsToTarget(target, terms);
-  if (!target) {
-    continue;
-  }
-  if (target.errors.length) {
-    throw target.errors[0];
-  }
-  if (!target.os) {
-    // TODO make target null, or create error for this
-    console.warn(`no os for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  if (!target.arch) {
-    // TODO make target null, or create error for this
-    console.warn(`no arch for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  if (!target.libc) {
-    // TODO make target null, or create error for this
-    console.warn(`no libc for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  let triplet = `${target.os}-${target.arch}-${target.libc}`;
-  uaTargetsMap[triplet] = target;
-}
-let uaTargets = [];
-let triplets = Object.keys(uaTargetsMap);
-for (let triplet of triplets) {
-  let target = uaTargetsMap[triplet];
-  uaTargets.push(target);
-}
-
-function showDirs(dirs) {
-  {
-    let errors = Object.keys(dirs.errors);
-    console.error('');
-    console.error(`Errors: ${errors.length}`);
-    for (let name of errors) {
-      let err = dirs.errors[name];
-      console.error(`${name}/: ${err.message}`);
-    }
-  }
-
-  {
-    let hidden = Object.keys(dirs.hidden);
-    console.debug('');
-    console.debug(`Hidden: ${hidden.length}`);
-    for (let name of hidden) {
-      let kind = dirs.hidden[name];
-      if (kind === '!directory') {
-        console.debug(`    ${name}`);
-      } else {
-        console.debug(`    ${name}/`);
-      }
-    }
-  }
-
-  {
-    let alias = Object.keys(dirs.alias);
-    console.debug('');
-    console.debug(`Alias: ${alias.length}`);
-    for (let name of alias) {
-      let kind = dirs.alias[name];
-      if (kind === 'symlink') {
-        console.debug(`    ${name} => ...`);
-      } else {
-        console.debug(`    ${name}/`);
-      }
-    }
-  }
-
-  {
-    let invalids = Object.keys(dirs.invalid);
-    console.warn('');
-    console.warn(`Invalid: ${invalids.length}`);
-    for (let name of invalids) {
-      console.warn(`    ${name}/`);
-    }
-  }
-
-  {
-    let selfhosted = Object.keys(dirs.selfhosted);
-    console.info('');
-    console.info(`Self-Hosted: ${selfhosted.length}`);
-    for (let name of selfhosted) {
-      console.info(`    ${name}/`);
-    }
-  }
-
-  {
-    let valids = Object.keys(dirs.valid);
-    console.info('');
-    console.info(`Found: ${valids.length}`);
-    for (let name of valids) {
-      console.info(`    ${name}/`);
-    }
-  }
-}
-
-let bc = BuildsCacher.create({
-  caches: CACHE_DIR,
-  installers: INSTALLERS_DIR,
-});
-
-async function main() {
-  /* jshint maxcomplexity: 25 */
-  // TODO
-  //     node ./_webi/lint-builds.js caddy@beta 'x86_64/unknown Darwin libc'
-  //
-  //let [projName, userAgent] = process.argv.slice(2);
-  let projName = process.argv[2];
-  // create test case for zoxide, goreleaser, go, yq, caddy, rg
-
-  let dirs = await bc.getProjectsByType();
-  if (!projName) {
-    showDirs(dirs);
-    console.info('');
-  }
-
-  let rows = [];
-  let triples = [];
-  let valids = Object.keys(dirs.valid);
-
-  if (projName) {
-    if (!valids.includes(projName)) {
-      throw new Error(`'${projName}' is not a valid installable project`);
-    }
-    valids = [projName];
-  }
-  //valids = ['atomicparsley', 'caddy', 'macos'];
-  //valids = ['atomicparsley'];
-
-  console.info('');
-  console.info(`Fetching project release assets`);
-  let parallel = 25;
-  let projects = [];
-  await Parallel.run(parallel, valids, getAll);
-  async function getAll(name, i) {
-    console.info(`    ${name}`);
-    let projInfo = await bc.getPackages({
-      //Releases: Releases,
-      name: name,
-      date: new Date(),
-    });
-    projects[i] = projInfo;
-  }
-
-  console.info(`Classifying build assets for...`);
-  for (let projInfo of projects) {
-    console.info(`    ${projInfo.name}`);
-
-    let nStr = projInfo.releases.length.toString();
-    let n = nStr.padStart(5, ' ');
-    let row = `##### ${n}\t${projInfo.name}\tv`;
-    rows.push(row);
-
-    // ignore known, non-package extensions
-    for (let build of projInfo.releases) {
-      let target = bc.classify(projInfo, build);
-      if (!target) {
-        // non-build file
-        continue;
-      }
-
-      if (target.error) {
-        let e = target.error;
-        if (e.code === 'E_BUILD_NO_PATTERN') {
-          console.warn(`>>> ${e.message} <<<`);
-          console.warn(projInfo);
-          console.warn(build);
-          console.warn(`^^^ ${e.message} ^^^`);
-        }
-        throw e;
-      }
-
-      if (target.unknownTerms?.length) {
-        let msg = `${projInfo.name}: unrecognized term(s) '${target.unknownTerms}' in '${build.download}'`;
-        let err = new Error(msg);
-        throw err;
-      }
-
-      triples.push(target.triplet);
-      // if (!build.version) {
-      //   throw new Error(`no version for ${pkg.name} ${build.name}`);
-      // }
-      // // For debug printing versions
-      // console.error(build.version);
-      rows.push(`${target.triplet}\t${projInfo.name}\t${build.version}`);
-    }
-  }
-
-  console.info(`Fetching builds for`);
-  for (let projInfo of projects) {
-    console.info('');
-    console.info('');
-    console.info(`    ${projInfo.name}`);
-
-    for (let target of uaTargets) {
-      let libc = target.libc || 'libc';
-      let hostTriplet = `${target.os}-${target.arch}-${libc}`;
-      console.info('');
-      console.info(`    target: ${hostTriplet}`);
-      let match = bc.findMatchingPackages(projInfo, target, {
-        ver: '',
-      });
-      if (!match) {
-        console.info(
-          `    project: ${projInfo.name}: missing build for os '${target.os}'`,
-        );
-        continue;
-      }
-
-      if (!match.releases) {
-        console.info(
-          `    project: ${projInfo.name}: missing build for os '${target.os}-${target.arch}-${libc}'`,
-        );
-      } else if (match.triplet === hostTriplet) {
-        let releaseNames = Object.keys(match.releases);
-        console.info(`    selected ${releaseNames.length}`);
-      } else {
-        let releaseNames = Object.keys(match.releases);
-        console.info(
-          `    selected ${releaseNames.length} (${match.triplet} fallback)`,
-        );
-      }
-    }
-  }
-
-  let tsv = rows.join('\n');
-  console.info('');
-  console.info('#rows', rows.length);
-  await Fs.writeFile('builds.tsv', tsv, 'utf8');
-
-  console.info('');
-  console.info('Triplets Detected:');
-  let triplets = Object.keys(bc._triplets);
-  if (triplets.length) {
-    triplets.sort();
-    console.info('   ', triplets.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  console.info('New / Unknown Terms:');
-  let unknowns = Object.keys(bc.unknownTerms);
-  if (unknowns.length) {
-    unknowns.sort();
-    console.warn('   ', unknowns.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  console.info('Unused Terms:');
-  let unuseds = Object.keys(bc.orphanTerms);
-  if (unuseds.length) {
-    unuseds.sort();
-    console.warn('   ', unuseds.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  console.info('Formats:');
-  if (bc.formats.length) {
-    let formats = bc.formats.slice();
-    formats.sort();
-    if (!formats[0]) {
-      formats[0] = '(bin)';
-    }
-    console.warn('   ', formats.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  // sort -u -k1 builds.tsv | rg -v '^#|^https?:' | rg -i arm
-  // cut -f1 builds.tsv | sort -u -k1 | rg -v '^#|^https?:' | rg -i arm
-}
-
-if (module === require.main) {
-  let times = [];
-  let now = Date.now();
-  main()
-    .then(async function () {
-      let then = Date.now();
-      let delta = then - now;
-      times.push(delta);
-      now = then;
-      await main();
-      then = Date.now();
-      delta = then - now;
-      times.push(delta);
-    })
-    .then(function () {
-      console.info('');
-      console.info('Run times');
-      for (let delta of times) {
-        let s = delta / 1000;
-        console.info(`    ${s}`);
-      }
-
-      function forceExit() {
-        console.warn(`warn: dangling event loop reference`);
-        process.exit(0);
-      }
-      let exitTimeout = setTimeout(forceExit, 250);
-      exitTimeout.unref();
-    })
-    .catch(function (err) {
-      console.error(err.stack || err);
-      process.exit(1);
-    });
-}

_webi/normalize.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// this may need customizations between packages
+var osMap = {
+  macos: /(\b|_)(apple|os(\s_-)?x\b|mac|darwin|iPhone|iOS|iPad)/i,
+  linux: /(\b|_)(linux)/i,
+  freebsd: /(\b|_)(freebsd)/i,
+  windows: /(\b|_)(win|microsoft|msft)/i,
+  sunos: /(\b|_)(sun)/i,
+  aix: /(\b|_)(aix)/i
+};
+
+var maps = {
+  oses: {},
+  arches: {},
+  formats: {}
+};
+
+Object.keys(osMap).forEach(function (name) {
+  maps.oses[name] = true;
+});
+
+var formats = ['zip', 'xz', 'tar', 'pkg', 'msi', 'git', 'exe', 'dmg'];
+formats.forEach(function (name) {
+  maps.formats[name] = true;
+});
+
+// evaluation order matters
+// (i.e. otherwise x86 and x64 can cross match)
+var arches = [
+  'amd64', // first and most likely match
+  'arm64',
+  'x86',
+  'ppc64le',
+  'ppc64',
+  'armv7l',
+  'armv6l',
+  's390x'
+];
+var archMap = {
+  //amd64: /(amd.?64|x64|[_\-]64)/i,
+  amd64: /(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)64([_\-]?bit)?(\b|_)/i,
+  //x86: /(86)(\b|_)/i,
+  x86: /(\b|_|amd|(dar)?win(dows)?|mac(os)?|linux|osx|x)(86|32)([_\-]?bit)(\b|_)/i,
+  ppc64le: /(\b|_)(ppc64le)/i,
+  ppc64: /(\b|_)(ppc64)(\b|_)/i,
+  arm64: /(\b|_)((aarch|arm)64|arm)/i,
+  armv7l: /(\b|_)(armv?7l)/i,
+  armv6l: /(\b|_)(aarch32|armv?6l)/i,
+  s390x: /(\b|_)(s390x)/i
+};
+arches.forEach(function (name) {
+  maps.arches[name] = true;
+});
+
+function normalize(all) {
+  var supported = {
+    oses: {},
+    arches: {},
+    formats: {}
+  };
+
+  all.releases.forEach(function (rel) {
+    rel.version = rel.version.replace(/^v/i, '');
+    if (!rel.name) {
+      rel.name = rel.download.replace(/.*\//, '');
+    }
+    if (!rel.os) {
+      rel.os =
+        Object.keys(osMap).find(function (regKey) {
+          return osMap[regKey].test(rel.name || rel.download);
+        }) || 'unknown';
+    }
+    supported.oses[rel.os] = true;
+
+    if (!rel.arch) {
+      arches.some(function (regKey) {
+        var arch = (rel.name || rel.download).match(archMap[regKey]) && regKey;
+        if (arch) {
+          rel.arch = arch;
+          return true;
+        }
+      });
+    }
+    if (!rel.arch) {
+      if ('macos' === rel.os) {
+        rel.arch = 'amd64';
+      }
+    }
+    supported.arches[rel.arch] = true;
+
+    var tarExt;
+    if (!rel.ext) {
+      // pkg-v1.0.tar.gz => ['gz', 'tar', '0', 'pkg-v1']
+      // pkg-v1.0.tar => ['tar', '0' ,'pkg-v1']
+      // pkg-v1.0.zip => ['zip', '0', 'pkg-v1']
+      var exts = (rel.name || rel.download).split('.');
+      if (1 === exts.length) {
+        // for bare releases in the format of foo-linux-amd64
+        rel.ext = 'exe';
+      }
+      exts = exts.reverse().slice(0, 2);
+      if ('tar' === exts[1]) {
+        rel.ext = exts.reverse().join('.');
+        tarExt = 'tar';
+      } else if ('tgz' == exts[0]) {
+        rel.ext = 'tar.gz';
+        tarExt = 'tar';
+      } else {
+        rel.ext = exts[0];
+      }
+      if (/\-|linux|mac|os[_\-]?x|arm|amd|86|64|mip/i.test(rel.ext)) {
+        // for bare releases in the format of foo.linux-amd64
+        rel.ext = 'exe';
+      }
+    }
+    supported.formats[tarExt || rel.ext] = true;
+
+    if (all.download) {
+      rel.download = all.download.replace(/{{ download }}/, rel.download);
+    }
+  });
+
+  all.oses = Object.keys(supported.oses).filter(function (name) {
+    return maps.oses[name];
+  });
+  all.arches = Object.keys(supported.arches).filter(function (name) {
+    return maps.arches[name];
+  });
+  all.formats = Object.keys(supported.formats).filter(function (name) {
+    return maps.formats[name];
+  });
+
+  return all;
+}
+
+module.exports = normalize;
+module.exports._debug = function (all) {
+  all = normalize(all);
+  all.releases = all.releases
+    .filter(function (r) {
+      return ['windows', 'macos', 'linux'].includes(r.os) && 'amd64' === r.arch;
+    })
+    .slice(0, 10);
+  return all;
+};
+// NOT in order of priority (which would be tar, xz, zip, ...)
+module.exports.formats = formats;
+module.exports.arches = arches;
+module.exports.formatsMap = maps.formats;

_webi/package-install.tpl.ps1

@@ -1,155 +0,0 @@
-#!/usr/bin/env pwsh
-#350 check if windows user run as admin
-
-# this allows us to call ps1 files, which allows us to have spaces in filenames
-# ('powershell "$Env:USERPROFILE\test.ps1" foo' will fail if it has a space in
-# the path but '& "$Env:USERPROFILE\test.ps1" foo' will work even with a space)
-Set-ExecutionPolicy -Scope Process Bypass
-
-# If a command returns an error, halt the script.
-$ErrorActionPreference = 'Stop'
-
-# Ignore progress events from cmdlets so Invoke-WebRequest is not painfully slow
-$ProgressPreference = 'SilentlyContinue'
-
-$Env:WEBI_HOST = 'https://webinstall.dev'
-#$Env:WEBI_PKG = 'node@lts'
-#$Env:PKG_NAME = node
-#$Env:WEBI_VERSION = v12.16.2
-#$Env:WEBI_GIT_TAG = 12.16.2
-#$Env:WEBI_PKG_URL = "https://.../node-....zip"
-#$Env:WEBI_PKG_FILE = "node-v12.16.2-win-x64.zip"
-#$Env:WEBI_PKG_PATHNAME = "node-v12.16.2-win-x64.zip"
-
-# Switch to userprofile
-Push-Location $Env:USERPROFILE
-
-# Make paths
-New-Item -Path "$Env:USERPROFILE\Downloads" -ItemType Directory -Force | Out-Null
-New-Item -Path "$Env:USERPROFILE\.local\bin" -ItemType Directory -Force | Out-Null
-New-Item -Path "$Env:USERPROFILE\.local\opt" -ItemType Directory -Force | Out-Null
-
-# {{ baseurl }}
-# {{ version }}
-
-# See
-#   - <https://superuser.com/q/1264444>
-#   - <https://stackoverflow.com/a/60572643/151312>
-$Esc = [char]27
-$TTask = "${Esc}[36m"
-$TName = "${Esc}[1m${Esc}[32m"
-$TUrl = "${Esc}[2m"
-$TPath = "${Esc}[2m${Esc}[32m"
-$TCmd = "${Esc}[2m${Esc}[35m"
-$TDim = "${Esc}[2m"
-$TReset = "${Esc}[0m"
-
-function Invoke-DownloadUrl {
-    param (
-        [string]$URL,
-        [string]$Params,
-        [string]$Path,
-        [switch]$Force
-    )
-
-    if (Test-Path -Path "$Path") {
-        if (-not $Force.IsPresent) {
-            Write-Host "    ${TDim}Found${TReset} $Path"
-            return
-        }
-        Write-Host "    Updating ${TDim}${Path}${TDim}"
-    }
-
-    $TmpPath = "${Path}.part"
-    Remove-Item -Path $TmpPath -Force -ErrorAction Ignore
-
-    Write-Host "    Downloading ${TDim}from${TReset}"
-    Write-Host "      ${TDim}${URL}${TReset}"
-    if ($Params.Length -ne 0) {
-        Write-Host "        ?$Params"
-        $URL = "${URL}?${Params}"
-    }
-    curl.exe '-#' -f -sS -A $Env:WEBI_UA -L $URL | Out-File $TmpPath
-
-    Remove-Item -Path $Path -Force -ErrorAction Ignore
-    Move-Item $TmpPath $Path
-    Write-Host "      Saved ${TPath}${Path}${TReset}"
-}
-
-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 "") {
-        # This is the canonical CPU arch when the process is native
-        $my_arch = "$Env:PROCESSOR_ARCHITECTURE"
-    }
-
-    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*") {
-            $my_arch = "ARM64"
-        }
-    }
-
-    "PowerShell+curl Windows/10+ $my_arch msvc"
-}
-
-function webi_path_add($pathname) {
-    # C:\Users\me => C:/Users/me
-    $my_home = $Env:UserProfile
-    $my_home = $my_home.replace('\\', '/')
-    $my_home_re = [regex]::escape($my_home)
-
-    # ~/bin => %USERPROFILE%/bin
-    $pathname = $pathname.replace('~/', "$Env:UserProfile/")
-
-    # C:\Users\me\bin => %USERPROFILE%/bin
-    $my_pathname = $pathname.replace('\\', '/')
-    $my_pathname = $my_pathname -ireplace $my_home_re, "%USERPROFILE%"
-
-    $all_user_paths = [Environment]::GetEnvironmentVariable("Path", "User")
-    $user_paths = "${all_user_paths}".Trim(';').Split(';')
-    $exists_in_path = $false
-    foreach ($user_path in $user_paths) {
-        # C:\Users\me\bin => %USERPROFILE%/bin
-        $my_user_path = $user_path.replace('\\', '/')
-        $my_user_path = $my_user_path -ireplace $my_home_re, "%USERPROFILE%"
-
-        if ($my_user_path -ieq $my_pathname) {
-            $exists_in_path = $true
-        }
-    }
-    if (-not $exists_in_path) {
-        $all_user_paths = "${pathname};${all_user_paths}".Trim(';')
-        [Environment]::SetEnvironmentVariable("Path", $all_user_paths, "User")
-        $null = Sync-EnvPath
-    }
-}
-
-function Sync-EnvPath {
-    $UserPath = [Environment]::GetEnvironmentVariable("Path", "User").Trim(';')
-    $MachinePath = [Environment]::GetEnvironmentVariable("Path", "Machine").Trim(';')
-    $Env:Path = "${UserPath};${MachinePath}"
-    [Environment]::SetEnvironmentVariable("Path", $Env:Path)
-    $Env:Path
-}
-
-$Env:WEBI_UA = Get-UserAgent
-
-#$has_local_bin = echo "$Env:PATH" | Select-String -Pattern '\.local.bin'
-#if (!$has_local_bin)
-#{
-webi_path_add ~/.local/bin
-#}
-
-# {{ installer }}
-
-webi_path_add ~/.local/bin
-
-# Done
-Pop-Location

_webi/packages.js

@@ -1 +0,0 @@
-projects.js

_webi/packages.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var frontmarker = require('./frontmarker.js');
+var shmatter = require('shmatter');
+var fs = require('fs');
+var path = require('path');
+
+var pkgs = module.exports;
+pkgs.create = function (Pkgs, basepath) {
+  if (!Pkgs) {
+    Pkgs = {};
+  }
+  if (!basepath) {
+    basepath = path.join(__dirname, '../');
+  }
+
+  Pkgs.all = function () {
+    return fs.promises.readdir(basepath).then(function (nodes) {
+      var items = [];
+      return nodes
+        .reduce(function (p, node) {
+          return p.then(function () {
+            return pkgs.get(node).then(function (meta) {
+              if (meta && '_' !== node[0]) {
+                meta.name = node;
+                items.push(meta);
+              }
+            });
+          });
+        }, Promise.resolve())
+        .then(function () {
+          return items;
+        });
+    });
+  };
+
+  Pkgs.get = function (node) {
+    return fs.promises.access(path.join(basepath, node)).then(function () {
+      return Pkgs._get(node);
+    });
+  };
+  Pkgs._get = function (node) {
+    var yash = path.join(basepath, node, 'package.yash');
+    var curlbash = path.join(basepath, node, 'install.sh');
+    var readme = path.join(basepath, node, 'README.md');
+    var winstall = path.join(basepath, node, 'install.ps1');
+    return Promise.all([
+      fs.promises
+        .readFile(readme, 'utf-8')
+        .then(function (txt) {
+          // TODO
+          return frontmarker.parse(txt);
+        })
+        .catch(function (e) {
+          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+            console.error("failed to read '" + node + "/README.md'");
+            console.error(e);
+          }
+        }),
+      fs.promises
+        .readFile(yash, 'utf-8')
+        .then(function (txt) {
+          return shmatter.parse(txt);
+        })
+        .catch(function (e) {
+          // no yash package description
+          yash = '';
+          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+            console.error("failed to parse '" + node + "/package.yash'");
+            console.error(e);
+          }
+          return fs.promises.readFile(curlbash, 'utf-8').then(function (txt) {
+            return shmatter.parse(txt);
+          });
+        })
+        .catch(function (e) {
+          // no *nix installer
+          curlbash = '';
+          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+            console.error("failed to parse '" + node + "/install.sh'");
+            console.error(e);
+          }
+        }),
+      fs.promises.access(winstall).catch(function (e) {
+        // no winstaller
+        winstall = '';
+        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+          console.error("failed to read '" + node + "/install.ps1'");
+          console.error(e);
+        }
+      })
+    ]).then(function (items) {
+      var meta = items[0] || items[1];
+      if (!meta) {
+        // doesn't exist
+        return;
+      }
+      meta.windows = !!winstall;
+      meta.bash = !!curlbash;
+
+      return meta;
+    });
+  };
+
+  return Pkgs;
+};
+pkgs.create(pkgs);
+
+if (module === require.main) {
+  pkgs.all().then(function (data) {
+    console.info('package info:');
+    console.info(data);
+  });
+}

_webi/parallel.js

@@ -1,44 +0,0 @@
-'use strict';
-
-var Parallel = module.exports;
-Parallel.run = async function (limit, arr, fn) {
-  let index = 0;
-  let actives = [];
-  let results = [];
-  limit = Math.min(limit, arr.length);
-
-  function launch() {
-    let _index = index;
-    let p = fn(arr[_index], _index, arr);
-
-    // some tasks may be synchronous
-    // so we must push before removing
-    actives.push(p);
-
-    p.then(function _resolve(result) {
-      let i = actives.indexOf(p);
-      actives.splice(i, 1);
-      results[_index] = result;
-    });
-
-    index += 1;
-  }
-
-  // start tasks in parallel, up to limit
-  for (; actives.length < limit; ) {
-    launch();
-  }
-
-  // keep the task queue full
-  for (; index < arr.length; ) {
-    // wait for one task to complete
-    await Promise.race(actives);
-    // add one task again
-    launch();
-  }
-
-  // wait for all remaining tasks
-  await Promise.all(actives);
-
-  return results;
-};

_webi/projects.js

@@ -1,96 +0,0 @@
-'use strict';
-
-var frontmarker = require('./frontmarker.js');
-var fs = require('fs');
-var path = require('path');
-
-var pkgs = module.exports;
-pkgs.create = function (Pkgs, basepath) {
-  if (!Pkgs) {
-    Pkgs = {};
-  }
-  if (!basepath) {
-    basepath = path.join(__dirname, '../');
-  }
-
-  Pkgs.all = function () {
-    return fs.promises.readdir(basepath).then(function (nodes) {
-      var items = [];
-      return nodes
-        .reduce(function (p, node) {
-          return p.then(function () {
-            return pkgs.get(node).then(function (meta) {
-              if (meta && '_' !== node[0]) {
-                meta.name = node;
-                items.push(meta);
-              }
-            });
-          });
-        }, Promise.resolve())
-        .then(function () {
-          return items;
-        });
-    });
-  };
-
-  Pkgs.get = function (node) {
-    return fs.promises.access(path.join(basepath, node)).then(function () {
-      return Pkgs._get(node);
-    });
-  };
-  Pkgs._get = function (node) {
-    var curlbash = path.join(basepath, node, 'install.sh');
-    var readme = path.join(basepath, node, 'README.md');
-    var winstall = path.join(basepath, node, 'install.ps1');
-    return Promise.all([
-      fs.promises
-        .readFile(readme, 'utf-8')
-        .then(function (txt) {
-          // TODO
-          return frontmarker.parse(txt);
-        })
-        .catch(function (e) {
-          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-            console.error("failed to read '" + node + "/README.md'");
-            console.error(e);
-          }
-        }),
-      fs.promises.access(curlbash).catch(function (e) {
-        // no *nix installer
-        curlbash = '';
-        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-          console.error("failed to parse '" + node + "/install.sh'");
-          console.error(e);
-        }
-      }),
-      fs.promises.access(winstall).catch(function (e) {
-        // no winstaller
-        winstall = '';
-        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-          console.error("failed to read '" + node + "/install.ps1'");
-          console.error(e);
-        }
-      }),
-    ]).then(function (items) {
-      var meta = items[0] || items[1];
-      if (!meta) {
-        // doesn't exist
-        return;
-      }
-      meta.windows = !!winstall;
-      meta.bash = !!curlbash;
-
-      return meta;
-    });
-  };
-
-  return Pkgs;
-};
-pkgs.create(pkgs);
-
-if (module === require.main) {
-  pkgs.all().then(function (data) {
-    console.info('package info:');
-    console.info(data);
-  });
-}

_webi/releases.js

@@ -0,0 +1,251 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var request = require('@root/request');
+var _normalize = require('../_webi/normalize.js');
+
+var reInstallTpl = /\s*#?\s*{{ installer }}/;
+
+var Releases = module.exports;
+Releases.get = async function (pkgdir) {
+  var get;
+  try {
+    get = require(path.join(pkgdir, 'releases.js'));
+  } catch (e) {
+    throw new Error('no releases.js for', pkgdir.split(/[\/\\]+/).pop());
+  }
+  return get(request).then(function (all) {
+    return _normalize(all);
+  });
+};
+
+function padScript(txt) {
+  return txt.replace(/^/g, '        ');
+}
+
+Releases.renderBash = function (
+  pkgdir,
+  rel,
+  { baseurl, pkg, tag, ver, os, arch, formats }
+) {
+  if (!Array.isArray(formats)) {
+    formats = [];
+  }
+  if (!tag) {
+    tag = '';
+  }
+  return fs.promises
+    .readFile(path.join(pkgdir, 'install.sh'), 'utf8')
+    .then(function (installTxt) {
+      installTxt = padScript(installTxt);
+      var vers = rel.version.split('.');
+      var v = {
+        major: vers.shift() || '',
+        minor: vers.shift() || '',
+        patch: vers.join('.').replace(/[+\-].*/, ''),
+        build: vers
+          .join('.')
+          .replace(/[^+\-]*/, '')
+          .replace(/^-/, '')
+      };
+      var pkgFile = rel.filename || rel.name;
+      return fs.promises
+        .readFile(path.join(__dirname, 'template.sh'), 'utf8')
+        .then(function (tplTxt) {
+          return (
+            tplTxt
+              .replace(
+                /^\s*#?WEBI_PKG=.*/m,
+                "WEBI_PKG='" + pkg + '@' + ver + "'"
+              )
+              .replace(/^\s*#?WEBI_HOST=.*/m, "WEBI_HOST='" + baseurl + "'")
+              .replace(/^\s*#?WEBI_OS=.*/m, "WEBI_OS='" + (os || '') + "'")
+              .replace(
+                /^\s*#?WEBI_ARCH=.*/m,
+                "WEBI_ARCH='" + (arch || '') + "'"
+              )
+              .replace(/^\s*#?WEBI_TAG=.*/m, "WEBI_TAG='" + tag + "'")
+              .replace(
+                /^\s*#?WEBI_RELEASES=.*/m,
+                "WEBI_RELEASES='" +
+                  baseurl +
+                  '/api/releases/' +
+                  pkg +
+                  '@' +
+                  tag +
+                  '.tab?os=' +
+                  rel.os +
+                  '&arch=' +
+                  rel.arch +
+                  '&formats=' +
+                  formats.join(',') +
+                  '&pretty=true' +
+                  "'"
+              )
+              .replace(
+                /^\s*#?WEBI_CSV=.*/m,
+                "WEBI_CSV='" +
+                  [
+                    rel.version,
+                    rel.lts,
+                    rel.channel,
+                    rel.date,
+                    rel.os,
+                    rel.arch,
+                    rel.ext,
+                    '-',
+                    rel.download,
+                    rel.name,
+                    rel.comment || ''
+                  ]
+                    .join(',')
+                    .replace(/'/g, '') +
+                  "'"
+              )
+              .replace(
+                /^\s*#?WEBI_VERSION=.*/m,
+                'WEBI_VERSION=' + JSON.stringify(rel.version)
+              )
+              .replace(/^\s*#?WEBI_MAJOR=.*/m, 'WEBI_MAJOR=' + v.major)
+              .replace(/^\s*#?WEBI_MINOR=.*/m, 'WEBI_MINOR=' + v.minor)
+              .replace(/^\s*#?WEBI_PATCH=.*/m, 'WEBI_PATCH=' + v.patch)
+              .replace(/^\s*#?WEBI_BUILD=.*/m, 'WEBI_BUILD=' + v.build)
+              .replace(/^\s*#?WEBI_LTS=.*/m, 'WEBI_LTS=' + rel.lts)
+              .replace(/^\s*#?WEBI_CHANNEL=.*/m, 'WEBI_CHANNEL=' + rel.channel)
+              .replace(
+                /^\s*#?WEBI_EXT=.*/m,
+                'WEBI_EXT=' + rel.ext.replace(/tar.*/, 'tar')
+              )
+              .replace(
+                /^\s*#?WEBI_FORMATS=.*/m,
+                "WEBI_FORMATS='" + formats.join(',') + "'"
+              )
+              .replace(
+                /^\s*#?WEBI_PKG_URL=.*/m,
+                "WEBI_PKG_URL='" + rel.download + "'"
+              )
+              .replace(
+                /^\s*#?WEBI_PKG_FILE=.*/m,
+                "WEBI_PKG_FILE='" + pkgFile + "'"
+              )
+              // PKG details
+              .replace(/^\s*#?PKG_NAME=.*/m, "PKG_NAME='" + pkg + "'")
+              .replace(
+                /^\s*#?PKG_OSES=.*/m,
+                "PKG_OSES='" + ((rel && rel.oses) || []).join(',') + "'"
+              )
+              .replace(
+                /^\s*#?PKG_ARCHES=.*/m,
+                "PKG_ARCHES='" + ((rel && rel.arches) || []).join(',') + "'"
+              )
+              .replace(
+                /^\s*#?PKG_FORMATS=.*/m,
+                "PKG_FORMATS='" + ((rel && rel.formats) || []).join(',') + "'"
+              )
+              .replace(reInstallTpl, '\n' + installTxt)
+          );
+        });
+    });
+};
+
+Releases.renderBatch = function (
+  pkgdir,
+  rel,
+  { baseurl, pkg, tag, ver, os, arch, formats }
+) {
+  if (!Array.isArray(formats)) {
+    formats = [];
+  }
+  if (!tag) {
+    tag = '';
+  }
+  return fs.promises
+    .readFile(path.join(pkgdir, 'install.bat'), 'utf8')
+    .then(function (installTxt) {
+      installTxt = padScript(installTxt);
+      /*
+      var vers = rel.version.split('.');
+      var v = {
+        major: vers.shift() || '',
+        minor: vers.shift() || '',
+        patch: vers.join('.').replace(/[+\-].*$/, ''),
+        build: vers
+          .join('.')
+          .replace(/[^+\-]*()/, '')
+          .replace(/^-/, '')
+      };
+      */
+      return fs.promises
+        .readFile(path.join(__dirname, 'template.bat'), 'utf8')
+        .then(function (tplTxt) {
+          return tplTxt
+            .replace(
+              /^(REM )?WEBI_PKG=.*/im,
+              "WEBI_PKG='" + pkg + '@' + ver + "'"
+            )
+            .replace(reInstallTpl, '\n' + installTxt);
+        });
+    });
+};
+
+Releases.renderPowerShell = function (
+  pkgdir,
+  rel,
+  { baseurl, pkg, tag, ver, os, arch, formats }
+) {
+  if (!Array.isArray(formats)) {
+    formats = [];
+  }
+  if (!tag) {
+    tag = '';
+  }
+  return fs.promises
+    .readFile(path.join(pkgdir, 'install.ps1'), 'utf8')
+    .then(function (installTxt) {
+      installTxt = padScript(installTxt);
+      /*
+      var vers = rel.version.split('.');
+      var v = {
+        major: vers.shift() || '',
+        minor: vers.shift() || '',
+        patch: vers.join('.').replace(/[+\-].*$/, ''),
+        build: vers
+          .join('.')
+          .replace(/[^+\-]*()/, '')
+          .replace(/^-/, '')
+      };
+      */
+      return fs.promises
+        .readFile(path.join(__dirname, 'template.ps1'), 'utf8')
+        .then(function (tplTxt) {
+          var pkgver = pkg + '@' + ver;
+          return tplTxt
+            .replace(
+              /^(#)?\$Env:WEBI_HOST\s*=.*/im,
+              "$Env:WEBI_HOST = '" + baseurl + "'"
+            )
+            .replace(
+              /^(#)?\$Env:WEBI_PKG\s*=.*/im,
+              "$Env:WEBI_PKG = '" + pkgver + "'"
+            )
+            .replace(
+              /^(#)?\$Env:PKG_NAME\s*=.*/im,
+              "$Env:PKG_NAME = '" + pkg + "'"
+            )
+            .replace(
+              /^(#)?\$Env:WEBI_VERSION\s*=.*/im,
+              "$Env:WEBI_VERSION = '" + rel.version + "'"
+            )
+            .replace(
+              /^(#)?\$Env:WEBI_PKG_URL\s*=.*/im,
+              "$Env:WEBI_PKG_URL = '" + rel.download + "'"
+            )
+            .replace(
+              /^(#)?\$Env:WEBI_PKG_FILE\s*=.*/im,
+              "$Env:WEBI_PKG_FILE = '" + rel.name + "'"
+            )
+            .replace(reInstallTpl, '\n' + installTxt);
+        });
+    });
+};

_webi/serve-installer.js

@@ -1,304 +0,0 @@
-'use strict';
-
-var InstallerServer = module.exports;
-
-let Fs = require('fs/promises');
-let Path = require('path');
-
-let HostTargets = require('./build-classifier/host-targets.js');
-let Builds = require('./builds.js');
-let Installers = require('./installers.js');
-
-InstallerServer.INSTALLERS_DIR = Path.join(__dirname, '..');
-InstallerServer.serveInstaller = async function (
-  baseurl,
-  ua,
-  pkg,
-  tag,
-  ext,
-  formats,
-  libc,
-) {
-  let unameAgent = ua;
-  let projectName = pkg;
-  let [rel, tmplParams] = await InstallerServer.helper({
-    unameAgent,
-    projectName,
-    tag,
-    formats,
-    libc,
-  });
-  Object.assign(tmplParams, {
-    baseurl,
-  });
-
-  var pkgdir = Path.join(InstallerServer.INSTALLERS_DIR, projectName);
-  if ('ps1' === ext) {
-    return Installers.renderPowerShell(pkgdir, rel, tmplParams);
-  }
-  return Installers.renderBash(pkgdir, rel, tmplParams);
-};
-
-// TODO put some of this in a middleware? or common function?
-// TODO maybe move package/version/lts/channel detection into getReleases
-InstallerServer.helper = async function ({
-  unameAgent,
-  projectName,
-  tag,
-  formats,
-  libc,
-}) {
-  console.log(`dbg: Installer User-Agent: ${unameAgent}`);
-
-  let releaseTarget = toReleaseTarget(tag);
-  let hostFormats = formats;
-  let terms = unameAgent.split(/[\s\/]+/g);
-  let hostTarget = {};
-  try {
-    void HostTargets.termsToTarget(hostTarget, terms);
-  } catch (e) {
-    // if we can't guarantee the results...
-    // "in the face of ambiguity, refuse the temptation to guess"
-    throw e;
-  }
-  console.log(`dbg: Installer Host Target:`);
-  console.log(hostTarget);
-
-  if (!hostTarget.os) {
-    throw new Error(`OS could not be identified by User-Agent '${unameAgent}'`);
-  }
-
-  console.log(`dbg: Get Project Installer Type for '${projectName}':`);
-  let proj = await Builds.getProjectType(projectName);
-  if (proj.type === 'alias') {
-    console.log(`dbg: alias`, proj);
-    projectName = proj.detail;
-    proj = await Builds.getProjectType(projectName); // an alias should never resolve to an alias
-  }
-  console.log(`dbg: proj`, proj);
-
-  let validTypes = ['selfhosted', 'valid'];
-  if (!validTypes.includes(proj.type)) {
-    let msg = `'${projectName}' doesn't have an installer: '${proj.type}': '${proj.detail}'`;
-    let err = new Error(msg);
-    err.code = 'ENOENT';
-    throw err;
-  }
-
-  let tmplParams = {
-    pkg: projectName,
-    tag: tag,
-    os: hostTarget.os,
-    arch: hostTarget.arch,
-    libc: hostTarget.libc,
-    formats: hostFormats,
-    limit: 1,
-  };
-  Object.assign(tmplParams, releaseTarget);
-  console.log('tmplParams', tmplParams);
-
-  let errPackage = {
-    name: 'doesntexist.ext',
-    version: '0.0.0',
-    lts: '-',
-    channel: 'error',
-    date: '1970-01-01',
-    os: hostTarget.os || '-',
-    arch: hostTarget.arch || '-',
-    libc: hostTarget.libc || '-',
-    ext: 'err',
-    download: 'https://example.com/doesntexist.ext',
-    comment:
-      'No matches found. Could be bad or missing version info' +
-      ',' +
-      "Check query parameters. Should be something like '/api/releases/{package}@{version}.tab?os={macos|linux|windows|-}&arch={amd64|x86|aarch64|arm64|armv7l|-}&libc={musl|gnu|msvc|libc|static}&limit=10'",
-  };
-
-  if (proj.type === 'selfhosted') {
-    return [errPackage, tmplParams];
-  }
-
-  let projInfo = await Builds.getPackage({
-    name: projectName,
-    date: new Date(),
-  });
-  let latestVersions = Builds.enumerateLatestVersions(projInfo);
-  //console.log('projInfo', projInfo);
-
-  let buildTargetInfo = {
-    triplets: projInfo.triplets,
-    oses: projInfo.oses,
-    arches: projInfo.arches,
-    libcs: projInfo.libcs,
-    formats: projInfo.formats,
-    latest: latestVersions.latest,
-    stable: latestVersions.stable,
-  };
-
-  // TODO .findMatchingPackages() should probably account for this
-  let hasOs = projInfo.oses.includes(hostTarget.os);
-  let maybePosix = !hasOs && hostTarget.os !== 'windows';
-  if (maybePosix) {
-    let posixes = ['posix_2017', 'posix_2024'];
-    for (let posixYear of posixes) {
-      let hasPosix = projInfo.oses.includes(posixYear);
-      if (hasPosix) {
-        hasOs = true;
-        break;
-      }
-    }
-  }
-  if (!hasOs) {
-    hasOs = projInfo.oses.includes('ANYOS');
-  }
-
-  if (!hasOs) {
-    let pkg1 = Object.assign(buildTargetInfo, errPackage);
-    return [pkg1, tmplParams];
-  }
-
-  let targetRelease = Builds.findMatchingPackages(
-    projInfo,
-    hostTarget,
-    releaseTarget,
-  );
-  // { triplet: `${os}-${arch}-${libc}`, packages: targetPackages
-  // , latest: projInfo.versions[0], versions: matchInfo
-  // }
-
-  if (!targetRelease?.packages) {
-    let pkg1 = Object.assign(buildTargetInfo, errPackage);
-    return [pkg1, tmplParams];
-  }
-
-  let buildPkg = Builds.selectPackage(targetRelease.packages, hostFormats);
-  let ext = buildPkg.ext || '.exe';
-  if (ext.startsWith('.')) {
-    ext = ext.slice(1);
-  }
-
-  let version = targetRelease.version;
-  if (version.startsWith('v')) {
-    version = version.slice(1);
-  }
-
-  buildPkg = Object.assign(buildTargetInfo, buildPkg, { ext, version });
-  console.log('dbg: buildPkg', buildPkg);
-  console.log('dbg: tmplParams', tmplParams);
-  return [buildPkg, tmplParams];
-};
-
-let channelNames = [
-  'stable',
-  // 'hotfix',
-  'latest',
-  'rc',
-  'preview',
-  'pre',
-  'dev',
-  'beta',
-  'alpha',
-];
-
-function toReleaseTarget(tag) {
-  tag = tag.replace(/^v/, '');
-
-  let releaseTarget = {
-    channel: '',
-    lts: false,
-    version: '',
-  };
-
-  if (tag === 'lts') {
-    releaseTarget.lts = true;
-    releaseTarget.channel = 'stable';
-  } else if (channelNames.includes(tag)) {
-    releaseTarget.channel = tag;
-  } else {
-    releaseTarget.version = tag;
-  }
-
-  return releaseTarget;
-}
-
-var CURL_PIPE_PS1_BOOT = Path.join(__dirname, 'curl-pipe-bootstrap.tpl.ps1');
-var CURL_PIPE_SH_BOOT = Path.join(__dirname, 'curl-pipe-bootstrap.tpl.sh');
-var BAD_SH_RE = /[<>'"`$\\]/;
-
-InstallerServer.getPosixCurlPipeBootstrap = async function ({
-  baseurl,
-  pkg,
-  ver,
-}) {
-  let bootTxt = await Fs.readFile(CURL_PIPE_SH_BOOT, 'utf8');
-
-  var webiPkg = [pkg, ver].filter(Boolean).join('@');
-  var webiChecksum = await Installers.getWebiShChecksum();
-  var envReplacements = [
-    ['WEBI_PKG', webiPkg],
-    ['WEBI_HOST', baseurl],
-    ['WEBI_CHECKSUM', webiChecksum],
-  ];
-
-  for (let env of envReplacements) {
-    let name = env[0];
-    let value = env[1];
-
-    let envRe = new RegExp(
-      `^[ \\t]*#?[ \\t]*(export[ \\t])?[ \\t]*(${name})=.*`,
-      'm',
-    );
-
-    if (BAD_SH_RE.test(value)) {
-      throw new Error(`key '${name}' has invalid value '${value}'`);
-    }
-
-    bootTxt = bootTxt.replace(envRe, `$1$2='${value}'`);
-  }
-  // TODO init config here
-  //bootTxt.replace(/CHEATSHEET_URL/g, `${Config.cheatUrl}/${pkg}`);
-
-  return bootTxt;
-};
-
-InstallerServer.getPwshCurlPipeBootstrap = async function ({
-  baseurl,
-  pkg,
-  ver,
-  exename,
-}) {
-  let bootTxt = await Fs.readFile(CURL_PIPE_PS1_BOOT, 'utf8');
-
-  var webiPkg = [pkg, ver].filter(Boolean).join('@');
-  //var webiChecksum = await InstallerServer.getWebiPs1Checksum();
-  var envReplacements = [
-    ['Env:WEBI_PKG', webiPkg],
-    ['Env:WEBI_HOST', baseurl],
-    //['Env:WEBI_CHECKSUM', webiChecksum],
-    ['baseurl', baseurl],
-    ['exename', exename],
-    ['version', ver],
-  ];
-
-  for (let env of envReplacements) {
-    let name = env[0];
-    let value = env[1];
-
-    if (BAD_SH_RE.test(value)) {
-      throw new Error(`key '${name}' has invalid value '${value}'`);
-    }
-
-    let tplRe = new RegExp(`{{ (${name}) }}`, 'g');
-    bootTxt = bootTxt.replace(tplRe, `${value}`);
-
-    let setRe = new RegExp(
-      `(#[ \\t]*)?(\\$${name})[ \\t]*=[ \\t]['"].*['"][ \\t]`,
-      'im',
-    );
-    bootTxt = bootTxt.replace(setRe, `$$${name} = '${value}'`);
-  }
-  // TODO init config here
-  //bootTxt.replace(/CHEATSHEET_URL/g, `${Config.cheatUrl}/${pkg}`);
-
-  return bootTxt;
-};

_webi/template.bat

@@ -0,0 +1,5 @@
+REM REM debug
+
+REM WEBI_PKG=
+
+{{ installer }}

_webi/template.ps1

@@ -0,0 +1,47 @@
+#!/usr/bin/env pwsh
+
+# this allows us to call ps1 files, which allows us to have spaces in filenames
+# ('powershell "$Env:USERPROFILE\test.ps1" foo' will fail if it has a space in
+# the path but '& "$Env:USERPROFILE\test.ps1" foo' will work even with a space)
+Set-ExecutionPolicy -Scope Process Bypass
+
+# If a command returns an error, halt the script.
+$ErrorActionPreference = 'Stop'
+
+# Ignore progress events from cmdlets so Invoke-WebRequest is not painfully slow
+$ProgressPreference = 'SilentlyContinue'
+
+$Env:WEBI_HOST = 'https://webinstall.dev'
+#$Env:WEBI_PKG = 'node@lts'
+#$Env:PKG_NAME = node
+#$Env:WEBI_VERSION = v12.16.2
+#$Env:WEBI_PKG_URL = "https://.../node-....zip"
+#$Env:WEBI_PKG_FILE = "node-v12.16.2-win-x64.zip"
+
+# Switch to userprofile
+pushd $Env:USERPROFILE
+
+# Make paths
+New-Item -Path Downloads -ItemType Directory -Force | out-null
+New-Item -Path .local\bin -ItemType Directory -Force | out-null
+New-Item -Path .local\opt -ItemType Directory -Force | out-null
+
+# {{ baseurl }}
+# {{ version }}
+
+function webi_add_path
+{
+    & "$Env:USERPROFILE\.local\bin\pathman.exe" add "$args[0]"
+    # Note: not all of these work as expected, so we use the unix-style, which is most consistent
+    #& "$Env:USERPROFILE\.local\bin\pathman.exe" add ~/.local/bin
+    #& "$Env:USERPROFILE\.local\bin\pathman.exe" add "$Env:USERPROFILE\.local\bin"
+    #& "$Env:USERPROFILE\.local\bin\pathman.exe" add %USERPROFILE%\.local\bin
+}
+
+# Run pathman to set up the folder
+& "$Env:USERPROFILE\.local\bin\pathman.exe" add ~/.local/bin
+
+{{ installer }}
+
+# Done
+popd

_webi/template.sh

@@ -0,0 +1,391 @@
+#!/bin/bash
+
+# shellcheck disable=2001
+# because I prefer to use sed rather than bash replace
+# (there's too little space in my head to learn both syntaxes)
+
+function __bootstrap_webi() {
+
+    set -e
+    set -u
+    #set -x
+
+    #WEBI_PKG=
+    #PKG_NAME=
+    # TODO should this be BASEURL instead?
+    #WEBI_OS=
+    #WEBI_ARCH=
+    #WEBI_HOST=
+    #WEBI_RELEASES=
+    #WEBI_CSV=
+    #WEBI_TAG=
+    #WEBI_VERSION=
+    #WEBI_MAJOR=
+    #WEBI_MINOR=
+    #WEBI_PATCH=
+    # TODO not sure if BUILD is the best name for this
+    #WEBI_BUILD=
+    #WEBI_LTS=
+    #WEBI_CHANNEL=
+    #WEBI_EXT=
+    #WEBI_FORMATS=
+    #WEBI_PKG_URL=
+    #WEBI_PKG_FILE=
+    #PKG_OSES=
+    #PKG_ARCHES=
+    #PKG_FORMATS=
+    WEBI_UA="$(uname -a)"
+    export WEBI_HOST
+
+    ##
+    ## Set up tmp, download, and install directories
+    ##
+
+    WEBI_TMP=${WEBI_TMP:-"$(mktemp -d -t webinstall-"${WEBI_PKG:-}".XXXXXXXX)"}
+    export _webi_tmp="${_webi_tmp:-"$HOME/.local/opt/webi-tmp.d"}"
+
+    mkdir -p "$HOME/Downloads"
+    mkdir -p "$HOME/.local/bin"
+    mkdir -p "$HOME/.local/opt"
+
+    ##
+    ## Detect http client
+    ##
+    set +e
+    WEBI_CURL="$(command -v curl)"
+    export WEBI_CURL
+    WEBI_WGET="$(command -v wget)"
+    export WEBI_WGET
+    set -e
+
+    # get the special formatted version (i.e. "go is go1.14" while node is "node v12.10.8")
+    my_versioned_name=""
+    _webi_canonical_name() {
+        if [ -n "$my_versioned_name" ]; then
+            echo "$my_versioned_name"
+            return 0
+        fi
+
+        if [ -n "$(command -v pkg_format_cmd_version)" ]; then
+            my_versioned_name="$(pkg_format_cmd_version "$WEBI_VERSION")"
+        else
+            my_versioned_name="'$pkg_cmd_name' v$WEBI_VERSION"
+        fi
+
+        echo "$my_versioned_name"
+    }
+
+    # update symlinks according to $HOME/.local/opt and $HOME/.local/bin install paths.
+    # shellcheck disable=2120
+    # webi_link may be used in the templated install script
+    webi_link() {
+        if [ -n "$(command -v pkg_link)" ]; then
+            pkg_link
+            return 0
+        fi
+
+        if [ -n "$WEBI_SINGLE" ] || [ "single" == "${1:-}" ]; then
+            rm -rf "$pkg_dst_cmd"
+            ln -s "$pkg_src_cmd" "$pkg_dst_cmd"
+        else
+            # 'pkg_dst' will default to $HOME/.local/opt/<pkg>
+            # 'pkg_src' will be the installed version, such as to $HOME/.local/opt/<pkg>-<version>
+            rm -rf "$pkg_dst"
+            ln -s "$pkg_src" "$pkg_dst"
+        fi
+    }
+
+    # detect if this program is already installed or if an installed version may cause conflict
+    webi_check() {
+        # Test for existing version
+        set +e
+        my_path="$PATH"
+        PATH="$(dirname "$pkg_dst_cmd"):$PATH"
+        export PATH
+        my_current_cmd="$(command -v "$pkg_cmd_name")"
+        set -e
+        if [ -n "$my_current_cmd" ]; then
+            pkg_current_version="$(pkg_get_current_version 2> /dev/null | head -n 1)"
+            # remove trailing '.0's for golang's sake
+            my_current_version="$(echo "$pkg_current_version" | sed 's:\.0::g')"
+            my_src_version="$(echo "$WEBI_VERSION" | sed 's:\.0::g')"
+            my_canonical_name="$(_webi_canonical_name)"
+            if [ "$my_src_version" == "$my_current_version" ]; then
+                echo "$my_canonical_name already installed at $my_current_cmd"
+                exit 0
+            else
+                if [ "$my_current_cmd" != "$pkg_dst_cmd" ]; then
+                    echo >&2 "WARN: possible conflict between $my_canonical_name and $pkg_current_version at $my_current_cmd"
+                fi
+                if [ -x "$pkg_src_cmd" ]; then
+                    # shellcheck disable=2119
+                    # this function takes no args
+                    webi_link
+                    echo "switched to $my_canonical_name at $pkg_src"
+                    exit 0
+                fi
+            fi
+        fi
+        export PATH="$my_path"
+    }
+
+    # detect if file is downloaded, and how to download it
+    webi_download() {
+        if [ -n "${1:-}" ]; then
+            my_url="$1"
+        else
+            if [ "error" == "$WEBI_CHANNEL" ]; then
+                # TODO pass back requested OS / Arch / Version
+                echo >&2 "Error: no '$PKG_NAME' release for '${WEBI_OS:-}' on '$WEBI_ARCH' as one of '$WEBI_FORMATS' by the tag '${WEBI_TAG:-}'"
+                echo >&2 "       '$PKG_NAME' is available for '$PKG_OSES' on '$PKG_ARCHES' as one of '$PKG_FORMATS'"
+                echo >&2 "       (check that the package name and version are correct)"
+                echo >&2 ""
+                echo >&2 "       Double check at $(echo "$WEBI_RELEASES" | sed 's:\?.*::')"
+                echo >&2 ""
+                exit 1
+            fi
+            my_url="$WEBI_PKG_URL"
+        fi
+        if [ -n "${2:-}" ]; then
+            my_dl="$2"
+        else
+            my_dl="$HOME/Downloads/$WEBI_PKG_FILE"
+        fi
+
+        if [ -e "$my_dl" ]; then
+            echo "Found $my_dl"
+            return 0
+        fi
+
+        echo "Downloading $PKG_NAME from"
+        echo "$my_url"
+
+        # It's only 2020, we can't expect to have reliable CLI tools
+        # to tell us the size of a file as part of a base system...
+        if [ -n "$WEBI_WGET" ]; then
+            # wget has resumable downloads
+            # TODO wget -c --content-disposition "$my_url"
+            set +e
+            my_show_progress=""
+            if [[ $- == *i* ]]; then
+                my_show_progress="--show-progress"
+            fi
+            if ! wget -q $my_show_progress --user-agent="wget $WEBI_UA" -c "$my_url" -O "$my_dl.part"; then
+                echo >&2 "failed to download from $WEBI_PKG_URL"
+                exit 1
+            fi
+            set -e
+        else
+            # Neither GNU nor BSD curl have sane resume download options, hence we don't bother
+            # TODO curl -fsSL --remote-name --remote-header-name --write-out "$my_url"
+            my_show_progress="-#"
+            if [[ $- == *i* ]]; then
+                my_show_progress=""
+            fi
+            # shellcheck disable=SC2086
+            # we want the flags to be split
+            curl -fSL $my_show_progress -H "User-Agent: curl $WEBI_UA" "$my_url" -o "$my_dl.part"
+        fi
+        mv "$my_dl.part" "$my_dl"
+
+        echo ""
+        echo "Saved as $my_dl"
+    }
+
+    # detect which archives can be used
+    webi_extract() {
+        pushd "$WEBI_TMP" > /dev/null 2>&1
+        if [ "tar" == "$WEBI_EXT" ]; then
+            echo "Extracting $HOME/Downloads/$WEBI_PKG_FILE"
+            tar xf "$HOME/Downloads/$WEBI_PKG_FILE"
+        elif [ "zip" == "$WEBI_EXT" ]; then
+            echo "Extracting $HOME/Downloads/$WEBI_PKG_FILE"
+            unzip "$HOME/Downloads/$WEBI_PKG_FILE" > __unzip__.log
+        elif [ "exe" == "$WEBI_EXT" ]; then
+            echo "Moving $HOME/Downloads/$WEBI_PKG_FILE"
+            mv "$HOME/Downloads/$WEBI_PKG_FILE" .
+        elif [ "xz" == "$WEBI_EXT" ]; then
+            echo "Inflating $HOME/Downloads/$WEBI_PKG_FILE"
+            unxz -c "$HOME/Downloads/$WEBI_PKG_FILE" > "$(basename "$WEBI_PKG_FILE")"
+        else
+            # do nothing
+            echo "Failed to extract $HOME/Downloads/$WEBI_PKG_FILE"
+            exit 1
+        fi
+        popd > /dev/null 2>&1
+    }
+
+    # use 'pathman' to update $HOME/.config/envman/PATH.env
+    webi_path_add() {
+        # make sure that we don't recursively install pathman with webi
+        my_path="$PATH"
+        export PATH="$HOME/.local/bin:$PATH"
+
+        # install pathman if not already installed
+        if [ -z "$(command -v pathman)" ]; then
+            "$HOME/.local/bin/webi" pathman > /dev/null
+        fi
+
+        export PATH="$my_path"
+
+        # in case pathman was recently installed and the PATH not updated
+        mkdir -p "$_webi_tmp"
+        # prevent "too few arguments" output on bash when there are 0 lines of stdout
+        "$HOME/.local/bin/pathman" add "$1" | grep "export" 2> /dev/null >> "$_webi_tmp/.PATH.env" || true
+    }
+
+    # group common pre-install tasks as default
+    webi_pre_install() {
+        webi_check
+        webi_download
+        webi_extract
+    }
+
+    # move commands from the extracted archive directory to $HOME/.local/opt or $HOME/.local/bin
+    # shellcheck disable=2120
+    # webi_install may be sourced and used elsewhere
+    webi_install() {
+        if [ -n "$WEBI_SINGLE" ] || [ "single" == "${1:-}" ]; then
+            mkdir -p "$(dirname "$pkg_src_cmd")"
+            mv ./"$pkg_cmd_name"* "$pkg_src_cmd"
+        else
+            rm -rf "$pkg_src"
+            mv ./"$pkg_cmd_name"* "$pkg_src"
+        fi
+    }
+
+    # run post-install functions - just updating PATH by default
+    webi_post_install() {
+        webi_path_add "$(dirname "$pkg_dst_cmd")"
+    }
+
+    _webi_enable_exec() {
+        if [ -n "$(command -v spctl)" ] && [ -n "$(command -v xattr)" ]; then
+            # note: some packages contain files that cannot be affected by xattr
+            xattr -r -d com.apple.quarantine "$pkg_src" || true
+            return 0
+        fi
+        # TODO need to test that the above actually worked
+        # (and proceed to this below if it did not)
+        if [ -n "$(command -v spctl)" ]; then
+            echo "Checking permission to execute '$pkg_cmd_name' on macOS 11+"
+            set +e
+            is_allowed="$(spctl -a "$pkg_src_cmd" 2>&1 | grep valid)"
+            set -e
+            if [ -z "$is_allowed" ]; then
+                echo ""
+                echo "##########################################"
+                echo "#  IMPORTANT: Permission Grant Required  #"
+                echo "##########################################"
+                echo ""
+                echo "Requesting permission to execute '$pkg_cmd_name' on macOS 10.14+"
+                echo ""
+                sleep 3
+                spctl --add "$pkg_src_cmd"
+            fi
+        fi
+    }
+
+    # a friendly message when all is well, showing the final install path in $HOME/.local
+    _webi_done_message() {
+        echo "Installed $(_webi_canonical_name) as $pkg_dst_cmd"
+    }
+
+    ##
+    ##
+    ## BEGIN custom override functions from <package>/install.sh
+    ##
+    ##
+
+    WEBI_SINGLE=
+
+    if [[ -z ${WEBI_WELCOME:-} ]]; then
+        echo ""
+        echo "Thanks for using webi to install '$PKG_NAME' on '$WEBI_OS/$WEBI_ARCH'."
+        echo "Have a problem? Experience a bug? Please let us know:"
+        echo "        https://github.com/webinstall/packages/issues"
+        echo ""
+    fi
+
+    function __init_installer() {
+
+        # do nothing - to satisfy parser prior to templating
+        echo -n ""
+
+        # {{ installer }}
+
+    }
+
+    __init_installer
+
+    ##
+    ##
+    ## END custom override functions
+    ##
+    ##
+
+    # run everything with defaults or overrides as needed
+    if [ -n "$(command -v pkg_get_current_version)" ]; then
+        pkg_cmd_name="${pkg_cmd_name:-$PKG_NAME}"
+
+        if [ -n "$WEBI_SINGLE" ]; then
+            pkg_dst_cmd="${pkg_dst_cmd:-$HOME/.local/bin/$pkg_cmd_name}"
+            pkg_dst="$pkg_dst_cmd" # "$(dirname "$(dirname $pkg_dst_cmd)")"
+
+            #pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name-v$WEBI_VERSION}"
+            pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name}"
+            pkg_src="$pkg_src_cmd" # "$(dirname "$(dirname $pkg_src_cmd)")"
+        else
+            pkg_dst="${pkg_dst:-$HOME/.local/opt/$pkg_cmd_name}"
+            pkg_dst_cmd="${pkg_dst_cmd:-$pkg_dst/bin/$pkg_cmd_name}"
+
+            pkg_src="${pkg_src:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION}"
+            pkg_src_cmd="${pkg_src_cmd:-$pkg_src/bin/$pkg_cmd_name}"
+        fi
+        # this script is templated and these are used elsewhere
+        # shellcheck disable=SC2034
+        pkg_src_bin="$(dirname "$pkg_src_cmd")"
+        # shellcheck disable=SC2034
+        pkg_dst_bin="$(dirname "$pkg_dst_cmd")"
+
+        if [[ -n "$(command -v pkg_pre_install)" ]]; then pkg_pre_install; else webi_pre_install; fi
+
+        pushd "$WEBI_TMP" > /dev/null 2>&1
+        echo "Installing to $pkg_src_cmd"
+        if [[ -n "$(command -v pkg_install)" ]]; then pkg_install; else webi_install; fi
+        chmod a+x "$pkg_src"
+        chmod a+x "$pkg_src_cmd"
+        popd > /dev/null 2>&1
+
+        webi_link
+
+        _webi_enable_exec
+        pushd "$WEBI_TMP" > /dev/null 2>&1
+        if [[ -n "$(command -v pkg_post_install)" ]]; then pkg_post_install; else webi_post_install; fi
+        popd > /dev/null 2>&1
+
+        pushd "$WEBI_TMP" > /dev/null 2>&1
+        if [[ -n "$(command -v pkg_done_message)" ]]; then pkg_done_message; else _webi_done_message; fi
+        popd > /dev/null 2>&1
+
+        echo ""
+    fi
+
+    webi_path_add "$HOME/.local/bin"
+    if [[ -z ${_WEBI_CHILD:-} ]] && [[ -f "$_webi_tmp/.PATH.env" ]]; then
+        if [[ -n $(cat "$_webi_tmp/.PATH.env") ]]; then
+            echo "You need to update your PATH to use $PKG_NAME:"
+            echo ""
+            sort -u "$_webi_tmp/.PATH.env"
+            rm -f "$_webi_tmp/.PATH.env"
+        fi
+    fi
+
+    # cleanup the temp directory
+    rm -rf "$WEBI_TMP"
+
+    # See? No magic. Just downloading and moving files.
+
+}
+
+__bootstrap_webi

_webi/test-api-compat.js

@@ -1,208 +0,0 @@
-'use strict';
-
-let Fs = require('node:fs/promises');
-let Path = require('node:path');
-
-let Releases = require('./transform-releases.js');
-
-let TESTDATA_DIR = Path.join(__dirname, 'testdata');
-
-// These mirror what the live API returns for /api/releases/{pkg}@stable.json?...
-let FILTERED_CASES = [
-  { pkg: 'bat', os: 'macos', arch: 'amd64' },
-  { pkg: 'bat', os: 'macos', arch: 'arm64' },
-  { pkg: 'bat', os: 'linux', arch: 'amd64' },
-  { pkg: 'bat', os: 'windows', arch: 'amd64' },
-  { pkg: 'go', os: 'macos', arch: 'amd64' },
-  { pkg: 'go', os: 'macos', arch: 'arm64' },
-  { pkg: 'go', os: 'linux', arch: 'amd64' },
-  { pkg: 'go', os: 'windows', arch: 'amd64' },
-  { pkg: 'rg', os: 'macos', arch: 'amd64' },
-  { pkg: 'rg', os: 'macos', arch: 'arm64' },
-  { pkg: 'rg', os: 'linux', arch: 'amd64' },
-  { pkg: 'rg', os: 'windows', arch: 'amd64' },
-  { pkg: 'caddy', os: 'macos', arch: 'amd64' },
-  { pkg: 'caddy', os: 'macos', arch: 'arm64' },
-  { pkg: 'caddy', os: 'linux', arch: 'amd64' },
-  { pkg: 'caddy', os: 'windows', arch: 'amd64' },
-];
-
-// Fields to compare between live and local
-let COMPARE_FIELDS = ['version', 'os', 'arch', 'ext', 'libc', 'channel', 'download'];
-
-async function main() {
-  let failures = 0;
-  let passes = 0;
-  let skips = 0;
-
-  // Test 1: Unfiltered release list — compare structure and field values
-  console.log('=== Test 1: Unfiltered /api/releases/{pkg}.json ===');
-  console.log('');
-  for (let pkg of ['bat', 'go', 'node', 'rg', 'jq', 'caddy']) {
-    let liveFile = `${TESTDATA_DIR}/live_${pkg}.json`;
-    let liveExists = await Fs.access(liveFile).then(
-      function () { return true; },
-      function () { return false; },
-    );
-    if (!liveExists) {
-      console.log(`  SKIP ${pkg}: no golden data`);
-      skips++;
-      continue;
-    }
-
-    let liveJson = await Fs.readFile(liveFile, 'utf8');
-    let liveReleases = JSON.parse(liveJson);
-
-    let localResult = await Releases.getReleases({
-      pkg: pkg,
-      ver: '',
-      os: '',
-      arch: '',
-      libc: '',
-      lts: false,
-      channel: '',
-      formats: [],
-      limit: 100,
-    });
-
-    let localReleases = localResult.releases;
-
-    // Compare OS vocabulary
-    let liveOses = [...new Set(liveReleases.map(function (r) { return r.os; }))].sort();
-    let localOses = [...new Set(localReleases.map(function (r) { return r.os; }))].sort();
-    let osMatch = JSON.stringify(liveOses) === JSON.stringify(localOses);
-    if (!osMatch) {
-      console.log(`  FAIL ${pkg} OS values: live=${JSON.stringify(liveOses)} local=${JSON.stringify(localOses)}`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg} OS values: ${JSON.stringify(liveOses)}`);
-      passes++;
-    }
-
-    // Compare arch vocabulary
-    let liveArches = [...new Set(liveReleases.map(function (r) { return r.arch; }))].sort();
-    let localArches = [...new Set(localReleases.map(function (r) { return r.arch; }))].sort();
-    let archMatch = JSON.stringify(liveArches) === JSON.stringify(localArches);
-    if (!archMatch) {
-      console.log(`  FAIL ${pkg} arch values: live=${JSON.stringify(liveArches)} local=${JSON.stringify(localArches)}`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg} arch values: ${JSON.stringify(liveArches)}`);
-      passes++;
-    }
-
-    // Compare latest version
-    let liveLatest = liveReleases[0]?.version;
-    let localLatest = localReleases[0]?.version;
-    if (liveLatest !== localLatest) {
-      // Version differences may be expected if cache is newer/older
-      console.log(`  WARN ${pkg} latest version: live=${liveLatest} local=${localLatest}`);
-    } else {
-      console.log(`  PASS ${pkg} latest version: ${liveLatest}`);
-      passes++;
-    }
-
-    // Compare ext vocabulary
-    let liveExts = [...new Set(liveReleases.map(function (r) { return r.ext; }))].sort();
-    let localExts = [...new Set(localReleases.map(function (r) { return r.ext; }))].sort();
-    let extMatch = JSON.stringify(liveExts) === JSON.stringify(localExts);
-    if (!extMatch) {
-      console.log(`  FAIL ${pkg} ext values: live=${JSON.stringify(liveExts)} local=${JSON.stringify(localExts)}`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg} ext values: ${JSON.stringify(liveExts)}`);
-      passes++;
-    }
-
-    // Compare that version strings don't have 'v' prefix
-    let localHasVPrefix = localReleases.some(function (r) {
-      return r.version.startsWith('v');
-    });
-    if (localHasVPrefix) {
-      console.log(`  FAIL ${pkg} versions have 'v' prefix (should be stripped)`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg} no 'v' prefix on versions`);
-      passes++;
-    }
-  }
-
-  // Test 2: Filtered queries — compare selected package for specific OS/arch
-  console.log('');
-  console.log('=== Test 2: Filtered /api/releases/{pkg}@stable.json?os=...&arch=... ===');
-  console.log('');
-  for (let tc of FILTERED_CASES) {
-    let fname = `live_${tc.pkg}_os_${tc.os}_arch_${tc.arch}.json`;
-    let liveFile = `${TESTDATA_DIR}/${fname}`;
-    let liveExists = await Fs.access(liveFile).then(
-      function () { return true; },
-      function () { return false; },
-    );
-    if (!liveExists) {
-      skips++;
-      continue;
-    }
-
-    let liveJson = await Fs.readFile(liveFile, 'utf8');
-    let liveReleases = JSON.parse(liveJson);
-    let liveFirst = liveReleases[0];
-    if (!liveFirst || liveFirst.channel === 'error') {
-      console.log(`  SKIP ${tc.pkg} ${tc.os}/${tc.arch}: live returned error/empty`);
-      skips++;
-      continue;
-    }
-
-    let localResult = await Releases.getReleases({
-      pkg: tc.pkg,
-      ver: '',
-      os: tc.os,
-      arch: tc.arch,
-      libc: '',
-      lts: false,
-      channel: 'stable',
-      formats: ['tar', 'zip', 'exe', 'xz'],
-      limit: 1,
-    });
-    let localFirst = localResult.releases[0];
-
-    if (!localFirst || localFirst.channel === 'error') {
-      console.log(`  FAIL ${tc.pkg} ${tc.os}/${tc.arch}: local returned error/empty, live had ${liveFirst.version}`);
-      failures++;
-      continue;
-    }
-
-    let diffs = [];
-    for (let field of COMPARE_FIELDS) {
-      let liveVal = String(liveFirst[field] || '');
-      let localVal = String(localFirst[field] || '');
-      if (liveVal !== localVal) {
-        // Version differences are OK if cache age differs
-        if (field === 'version' || field === 'download' || field === 'date') {
-          continue;
-        }
-        diffs.push(`${field}: live=${liveVal} local=${localVal}`);
-      }
-    }
-
-    if (diffs.length > 0) {
-      console.log(`  FAIL ${tc.pkg} ${tc.os}/${tc.arch}: ${diffs.join(', ')}`);
-      failures++;
-    } else {
-      let ver = localFirst.version;
-      let ext = localFirst.ext;
-      console.log(`  PASS ${tc.pkg} ${tc.os}/${tc.arch}: v${ver} .${ext}`);
-      passes++;
-    }
-  }
-
-  console.log('');
-  console.log(`=== Results: ${passes} passed, ${failures} failed, ${skips} skipped ===`);
-  if (failures > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-broad-resolve.js

@@ -1,77 +0,0 @@
-'use strict';
-
-// Broad sweep: test that all cached packages resolve on macOS arm64
-// and Linux amd64. Catches any package that completely fails to resolve.
-//
-// Usage: node _webi/test-broad-resolve.js
-
-var Path = require('node:path');
-var InstallerServer = require('./serve-installer.js');
-var Builds = require('./builds.js');
-var BuildsCacher = require('./builds-cacher.js');
-
-var UA_CASES = [
-  { label: 'macOS arm64', ua: 'aarch64/unknown Darwin/24.2.0 libc' },
-  { label: 'Linux amd64', ua: 'x86_64/unknown Linux/5.15.0 libc' },
-];
-
-async function main() {
-  console.log('Initializing build cache...');
-  await Builds.init();
-  console.log('');
-
-  var bc = BuildsCacher.create({
-    caches: Path.join(__dirname, '../_cache'),
-    installers: Path.join(__dirname, '..'),
-  });
-  var dirs = await bc.getProjectsByType();
-  var pkgs = Object.keys(dirs.valid).sort();
-  console.log('Testing ' + pkgs.length + ' packages...');
-  console.log('');
-
-  var pass = 0;
-  var fail = 0;
-  var failures = [];
-
-  for (var i = 0; i < pkgs.length; i++) {
-    var pkg = pkgs[i];
-    for (var j = 0; j < UA_CASES.length; j++) {
-      var tc = UA_CASES[j];
-      try {
-        var r = await InstallerServer.helper({
-          unameAgent: tc.ua,
-          projectName: pkg,
-          tag: 'stable',
-          formats: ['tar', 'exe', 'zip', 'xz', 'dmg'],
-          libc: '',
-        });
-        var p = r[0];
-        if (p.channel === 'error' || p.ext === 'err') {
-          failures.push(pkg + ' ' + tc.label + ': error (v' + p.version + ')');
-          fail++;
-        } else {
-          pass++;
-        }
-      } catch (e) {
-        failures.push(pkg + ' ' + tc.label + ': ' + e.message.substring(0, 60));
-        fail++;
-      }
-    }
-  }
-
-  if (failures.length > 0) {
-    console.log('Failures:');
-    for (var k = 0; k < failures.length; k++) {
-      console.log('  FAIL ' + failures[k]);
-    }
-    console.log('');
-  }
-
-  var total = pkgs.length * UA_CASES.length;
-  console.log('=== ' + pass + '/' + total + ' passed (' + fail + ' failed) ===');
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-cache-api-ready.js

@@ -1,277 +0,0 @@
-'use strict';
-
-// Tests that _cache JSON files are ready for direct use by the API endpoint
-// (transform-releases.js) WITHOUT needing normalize.js to fix up fields.
-//
-// These tests drive GOER to add missing features to ExportLegacy so that
-// normalize.js can be eliminated from the API path entirely.
-//
-// Usage: node _webi/test-cache-api-ready.js
-
-var Fs = require('node:fs');
-var Os = require('node:os');
-var Path = require('node:path');
-
-var CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-
-// Packages to spot-check (mix of github_releases, custom releases.js, gittag)
-var CHECK_PKGS = [
-  'bat',
-  'caddy',
-  'go',
-  'hugo',
-  'jq',
-  'node',
-  'rg',
-  'terraform',
-  'zig',
-];
-
-function loadReleases(dir, pkg) {
-  var file = Path.join(dir, pkg + '.json');
-  if (!Fs.existsSync(file)) {
-    return null;
-  }
-  try {
-    return JSON.parse(Fs.readFileSync(file, 'utf8'));
-  } catch (e) {
-    return null;
-  }
-}
-
-async function main() {
-  var passes = 0;
-  var failures = 0;
-
-  if (!Fs.existsSync(CACHE_DIR)) {
-    console.error('No cache directory at ' + CACHE_DIR);
-    process.exit(1);
-  }
-  console.log('Testing ' + CACHE_DIR);
-  console.log('');
-
-  // ================================================================
-  // Test 1: Version has no 'v' prefix
-  // ================================================================
-  console.log('=== Test 1: Version v-prefix stripped ===');
-  console.log('');
-
-  for (var vi = 0; vi < CHECK_PKGS.length; vi++) {
-    var vpkg = CHECK_PKGS[vi];
-    var vdata = loadReleases(CACHE_DIR, vpkg);
-    if (!vdata) {
-      console.log('  SKIP ' + vpkg + ': no data');
-      continue;
-    }
-
-    var vPrefixed = 0;
-    for (var vri = 0; vri < vdata.releases.length; vri++) {
-      var ver = vdata.releases[vri].version || '';
-      if (ver.startsWith('v')) {
-        vPrefixed++;
-      }
-    }
-
-    if (vPrefixed === 0) {
-      console.log('  PASS ' + vpkg + ': no v-prefixed versions');
-      passes++;
-    } else {
-      console.log('  FAIL ' + vpkg + ': ' + vPrefixed + '/' + vdata.releases.length + ' versions have v prefix');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 2: libc is never empty string (should be "none", "gnu", "musl", "msvc")
-  // ================================================================
-  console.log('');
-  console.log('=== Test 2: libc never empty ===');
-  console.log('');
-
-  for (var li = 0; li < CHECK_PKGS.length; li++) {
-    var lpkg = CHECK_PKGS[li];
-    var ldata = loadReleases(CACHE_DIR, lpkg);
-    if (!ldata) {
-      console.log('  SKIP ' + lpkg + ': no data');
-      continue;
-    }
-
-    var emptyLibc = 0;
-    for (var lri = 0; lri < ldata.releases.length; lri++) {
-      if (ldata.releases[lri].libc === '') {
-        emptyLibc++;
-      }
-    }
-
-    if (emptyLibc === 0) {
-      console.log('  PASS ' + lpkg + ': all entries have libc set');
-      passes++;
-    } else {
-      console.log('  FAIL ' + lpkg + ': ' + emptyLibc + '/' + ldata.releases.length + ' entries have empty libc (should be "none")');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 3: ext has no leading dot
-  // ================================================================
-  console.log('');
-  console.log('=== Test 3: ext has no leading dot ===');
-  console.log('');
-
-  for (var ei = 0; ei < CHECK_PKGS.length; ei++) {
-    var epkg = CHECK_PKGS[ei];
-    var edata = loadReleases(CACHE_DIR, epkg);
-    if (!edata) {
-      console.log('  SKIP ' + epkg + ': no data');
-      continue;
-    }
-
-    var dotExt = 0;
-    for (var eri = 0; eri < edata.releases.length; eri++) {
-      var ext = edata.releases[eri].ext || '';
-      if (ext.startsWith('.')) {
-        dotExt++;
-      }
-    }
-
-    if (dotExt === 0) {
-      console.log('  PASS ' + epkg + ': no leading dots on ext');
-      passes++;
-    } else {
-      console.log('  FAIL ' + epkg + ': ' + dotExt + '/' + edata.releases.length + ' entries have leading dot on ext');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 4: bare binaries have ext "exe" (not empty)
-  // ================================================================
-  console.log('');
-  console.log('=== Test 4: bare binaries have ext "exe" ===');
-  console.log('');
-
-  var barePkgs = ['jq', 'bat', 'rg', 'caddy'];
-  for (var bi = 0; bi < barePkgs.length; bi++) {
-    var bpkg = barePkgs[bi];
-    var bdata = loadReleases(CACHE_DIR, bpkg);
-    if (!bdata) {
-      console.log('  SKIP ' + bpkg + ': no data');
-      continue;
-    }
-
-    var emptyExt = 0;
-    for (var bri = 0; bri < bdata.releases.length; bri++) {
-      var brel = bdata.releases[bri];
-      if (brel.ext === '' && brel.name && !brel.name.includes('.')) {
-        emptyExt++;
-      }
-    }
-
-    if (emptyExt === 0) {
-      console.log('  PASS ' + bpkg + ': no bare binaries with empty ext');
-      passes++;
-    } else {
-      console.log('  FAIL ' + bpkg + ': ' + emptyExt + ' bare binaries have empty ext (should be "exe")');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 5: Top-level summary arrays present
-  // ================================================================
-  console.log('');
-  console.log('=== Test 5: Summary arrays (oses, arches, libcs, formats) ===');
-  console.log('');
-
-  for (var si = 0; si < CHECK_PKGS.length; si++) {
-    var spkg = CHECK_PKGS[si];
-    var sdata = loadReleases(CACHE_DIR, spkg);
-    if (!sdata) {
-      console.log('  SKIP ' + spkg + ': no data');
-      continue;
-    }
-
-    var missing = [];
-    if (!Array.isArray(sdata.oses)) { missing.push('oses'); }
-    if (!Array.isArray(sdata.arches)) { missing.push('arches'); }
-    if (!Array.isArray(sdata.libcs)) { missing.push('libcs'); }
-    if (!Array.isArray(sdata.formats)) { missing.push('formats'); }
-
-    if (missing.length === 0) {
-      // Verify they contain the right values
-      var hasMacos = sdata.oses.includes('macos') || sdata.oses.includes('darwin');
-      var hasLinux = sdata.oses.includes('linux');
-      var ok = true;
-      if (sdata.releases.some(function (r) { return r.os === 'macos' || r.os === 'darwin'; }) && !hasMacos) {
-        console.log('  FAIL ' + spkg + ': oses array missing macos/darwin');
-        failures++;
-        ok = false;
-      }
-      if (sdata.releases.some(function (r) { return r.os === 'linux'; }) && !hasLinux) {
-        console.log('  FAIL ' + spkg + ': oses array missing linux');
-        failures++;
-        ok = false;
-      }
-      if (ok) {
-        console.log('  PASS ' + spkg + ': has oses, arches, libcs, formats');
-        passes++;
-      }
-    } else {
-      console.log('  FAIL ' + spkg + ': missing top-level arrays: ' + missing.join(', '));
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 6: Version sort order — stable before beta, newest first
-  // ================================================================
-  console.log('');
-  console.log('=== Test 6: Version sort order ===');
-  console.log('');
-
-  var sortPkgs = ['go', 'node', 'terraform'];
-  for (var oi = 0; oi < sortPkgs.length; oi++) {
-    var opkg = sortPkgs[oi];
-    var odata = loadReleases(CACHE_DIR, opkg);
-    if (!odata) {
-      console.log('  SKIP ' + opkg + ': no data');
-      continue;
-    }
-
-    // Find first stable release
-    var firstStable = odata.releases.find(function (r) { return r.channel === 'stable'; });
-    // Find first beta release
-    var firstBeta = odata.releases.find(function (r) { return r.channel === 'beta'; });
-
-    if (!firstStable) {
-      console.log('  SKIP ' + opkg + ': no stable release');
-      continue;
-    }
-
-    // The first entry overall should be a stable release (newest stable > any beta)
-    // unless the beta is a newer version number
-    var firstEntry = odata.releases[0];
-    if (firstEntry.channel === 'stable') {
-      console.log('  PASS ' + opkg + ': first entry is stable (' + firstEntry.version + ')');
-      passes++;
-    } else {
-      console.log('  FAIL ' + opkg + ': first entry is ' + firstEntry.channel + ' (' + firstEntry.version + '), expected stable (' + firstStable.version + ')');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Summary
-  // ================================================================
-  console.log('');
-  console.log('=== Results: ' + passes + ' passed, ' + failures + ' failed ===');
-  if (failures > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-cache-compat.js

@@ -1,687 +0,0 @@
-'use strict';
-
-// Cache compatibility tests: verify that Go-generated cache files work
-// correctly with the Node build-classifier and installer resolution pipeline.
-//
-// Tests cover:
-//   1. Cache completeness — all packages have releases, required fields present
-//   2. Format selection — correct archive format per platform
-//   3. Edge-case platforms — FreeBSD, ARM variants, musl/Alpine
-//   4. Script generation — installer scripts render without error
-//   5. API compat — transform-releases output matches expected vocabulary
-//   6. Version format — no 'v' prefix, valid semver-ish
-//   7. Channel detection — stable vs beta correctly identified
-//
-// Usage: node _webi/test-cache-compat.js
-
-var Fs = require('node:fs');
-var Path = require('node:path');
-
-var InstallerServer = require('./serve-installer.js');
-var Builds = require('./builds.js');
-var Releases = require('./transform-releases.js');
-
-var CACHE_DIR = Path.join(require('node:os').homedir(), '.cache/webi/legacy');
-
-// ====================================================================
-// Test 1: Cache completeness — every package has releases with valid fields
-// ====================================================================
-
-// Packages that are expected to have binary releases (not gittag-only)
-var BINARY_PKGS = [
-  'bat',
-  'caddy',
-  'cmake',
-  'delta',
-  'deno',
-  'fd',
-  'fzf',
-  'gh',
-  'go',
-  'goreleaser',
-  'hugo',
-  'jq',
-  'k9s',
-  'node',
-  'ollama',
-  'rg',
-  'shellcheck',
-  'shfmt',
-  'syncthing',
-  'terraform',
-  'xz',
-  'yq',
-  'zig',
-  'zoxide',
-];
-
-// Packages that are gittag/source-only — must have releases but os/arch may be special
-var GITTAG_PKGS = [
-  'aliasman',
-  'serviceman',
-  'vim-airline',
-  'vim-go',
-  'vim-sensible',
-];
-
-// ====================================================================
-// Test 2: Format selection — correct ext per platform
-// ====================================================================
-
-// For these packages, verify the resolved format is correct for each platform.
-// Linux/macOS should get .tar.gz or .tar.xz (not .zip except for specific packages).
-// Windows should get .zip or .exe (not .tar.gz).
-var FORMAT_CASES = [
-  // Go projects — should be .tar.gz on Linux/macOS, .zip on Windows
-  {
-    label: 'go Linux amd64 format',
-    pkg: 'go',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'go Windows amd64 format',
-    pkg: 'go',
-    ua: 'x86_64/unknown Windows/10.0.19041 msvc',
-    expectExt: 'zip',
-  },
-  {
-    label: 'go macOS arm64 format',
-    pkg: 'go',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectExt: 'tar.gz',
-  },
-  // Rust projects — should be .tar.gz on Linux/macOS, .zip on Windows
-  {
-    label: 'bat Linux amd64 format',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'bat Windows amd64 format',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Windows/10.0.19041 msvc',
-    expectExt: 'zip',
-  },
-  {
-    label: 'rg Linux amd64 format',
-    pkg: 'rg',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'rg Windows amd64 format',
-    pkg: 'rg',
-    ua: 'x86_64/unknown Windows/10.0.19041 msvc',
-    expectExt: 'zip',
-  },
-  // Node — uses .tar.xz on Linux/macOS
-  {
-    label: 'node Linux amd64 format',
-    pkg: 'node',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'tar.xz',
-  },
-  {
-    label: 'node macOS arm64 format',
-    pkg: 'node',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectExt: 'tar.xz',
-  },
-  // delta — Rust, .tar.gz on Linux/macOS
-  {
-    label: 'delta Linux amd64 format',
-    pkg: 'delta',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'tar.gz',
-  },
-  // shfmt — Go, bare exe on Linux, .exe on Windows
-  {
-    label: 'shfmt Linux amd64 format',
-    pkg: 'shfmt',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectExt: 'exe',
-  },
-];
-
-// ====================================================================
-// Test 3: Edge-case platforms
-// ====================================================================
-
-var EDGE_CASES = [
-  // Linux ARM variants
-  {
-    label: 'go Linux aarch64',
-    pkg: 'go',
-    ua: 'aarch64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectNotError: true,
-  },
-  {
-    label: 'node Linux aarch64',
-    pkg: 'node',
-    ua: 'aarch64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectNotError: true,
-  },
-  // Alpine/musl — bat should resolve to musl build
-  {
-    label: 'bat Linux musl amd64',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Linux/5.15.0 musl',
-    expectOs: 'linux',
-    expectNotError: true,
-  },
-  {
-    label: 'rg Linux musl amd64',
-    pkg: 'rg',
-    ua: 'x86_64/unknown Linux/5.15.0 musl',
-    expectOs: 'linux',
-    expectNotError: true,
-  },
-  // node musl — separate musl build
-  {
-    label: 'node Linux musl amd64',
-    pkg: 'node',
-    ua: 'x86_64/unknown Linux/5.15.0 musl',
-    expectOs: 'linux',
-    expectNotError: true,
-  },
-  // FreeBSD — packages that have freebsd builds
-  {
-    label: 'syncthing FreeBSD amd64',
-    pkg: 'syncthing',
-    ua: 'x86_64/unknown FreeBSD/14.0 libc',
-    expectOs: 'freebsd',
-    expectNotError: true,
-  },
-  {
-    label: 'caddy FreeBSD amd64',
-    pkg: 'caddy',
-    ua: 'x86_64/unknown FreeBSD/14.0 libc',
-    expectOs: 'freebsd',
-    expectNotError: true,
-  },
-  // Windows aarch64 — should fallback to amd64 for most packages
-  {
-    label: 'go Windows aarch64',
-    pkg: 'go',
-    ua: 'aarch64/unknown Windows/10.0.22000 msvc',
-    expectOs: 'windows',
-    expectNotError: true,
-  },
-];
-
-// ====================================================================
-// Test 4: Script generation smoke tests
-// ====================================================================
-
-var SCRIPT_CASES = [
-  { pkg: 'bat', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'bat Linux' },
-  { pkg: 'go', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'go macOS' },
-  { pkg: 'node', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'node Linux' },
-  { pkg: 'rg', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'rg Windows' },
-  { pkg: 'jq', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'jq macOS' },
-  { pkg: 'caddy', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'caddy Linux' },
-  { pkg: 'shellcheck', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'shellcheck Linux' },
-  { pkg: 'shfmt', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'shfmt macOS' },
-  { pkg: 'hugo', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'hugo Linux' },
-  { pkg: 'delta', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'delta Linux' },
-  { pkg: 'fd', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'fd Linux' },
-  { pkg: 'fzf', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'fzf Linux' },
-  { pkg: 'zoxide', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'zoxide Linux' },
-  { pkg: 'k9s', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'k9s Linux' },
-  { pkg: 'yq', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'yq Linux' },
-];
-
-// ====================================================================
-// Test 5: API compat — transform-releases vocabulary
-// ====================================================================
-
-// The /api/releases/ endpoint uses normalize.js which has its own OS/arch names.
-// Verify that the Go cache produces correct values after normalization.
-var API_VOCAB_CASES = [
-  {
-    label: 'bat has macos+linux+windows',
-    pkg: 'bat',
-    expectOses: ['linux', 'macos', 'windows'],
-  },
-  {
-    label: 'go has macos+linux+windows',
-    pkg: 'go',
-    expectOses: ['linux', 'macos', 'windows'],
-  },
-  {
-    label: 'node has linux+macos+windows',
-    pkg: 'node',
-    expectOses: ['linux', 'macos', 'windows'],
-  },
-  {
-    label: 'syncthing has freebsd+linux+macos+windows',
-    pkg: 'syncthing',
-    expectOses: ['freebsd', 'linux', 'macos', 'windows'],
-  },
-  {
-    label: 'bat has amd64+arm64 arches',
-    pkg: 'bat',
-    expectArches: ['amd64', 'arm64'],
-  },
-  {
-    label: 'go has amd64+arm64 arches',
-    pkg: 'go',
-    expectArches: ['amd64', 'arm64'],
-  },
-];
-
-// ====================================================================
-// Test 6: Version format validation
-// ====================================================================
-
-var VERSION_CHECKS = [
-  'bat',
-  'go',
-  'node',
-  'rg',
-  'caddy',
-  'hugo',
-  'terraform',
-  'jq',
-  'cmake',
-  'zig',
-];
-
-// ====================================================================
-// Test 7: Channel detection
-// ====================================================================
-
-// Packages that should have both stable and beta releases
-var CHANNEL_CASES = [
-  {
-    label: 'go has stable releases',
-    pkg: 'go',
-    channel: 'stable',
-    expectMinCount: 10,
-  },
-  {
-    label: 'node has stable releases',
-    pkg: 'node',
-    channel: 'stable',
-    expectMinCount: 10,
-  },
-  {
-    label: 'cmake has stable releases',
-    pkg: 'cmake',
-    channel: 'stable',
-    expectMinCount: 5,
-  },
-];
-
-// ====================================================================
-// Runner
-// ====================================================================
-
-async function main() {
-  var passes = 0;
-  var failures = 0;
-  var knowns = 0;
-  var skips = 0;
-
-  console.log('Initializing build cache...');
-  await Builds.init();
-
-  if (!Fs.existsSync(CACHE_DIR)) {
-    console.error('No cache directory at ' + CACHE_DIR);
-    process.exit(1);
-  }
-  var cachePath = CACHE_DIR;
-  console.log('Using cache: ' + cachePath);
-  console.log('');
-
-  // ================================================================
-  // Test 1: Cache completeness
-  // ================================================================
-  console.log('=== Test 1: Cache Completeness ===');
-  console.log('');
-
-  for (var bi = 0; bi < BINARY_PKGS.length; bi++) {
-    var bpkg = BINARY_PKGS[bi];
-    var bfile = Path.join(cachePath, bpkg + '.json');
-    if (!Fs.existsSync(bfile)) {
-      console.log('  FAIL ' + bpkg + ': cache file missing');
-      failures++;
-      continue;
-    }
-    var bdata = JSON.parse(Fs.readFileSync(bfile, 'utf8'));
-    if (!bdata.releases || bdata.releases.length === 0) {
-      console.log('  FAIL ' + bpkg + ': 0 releases');
-      failures++;
-      continue;
-    }
-    // Check that at least one release has a download URL
-    var hasDownload = bdata.releases.some(function (r) {
-      return r.download && r.download.startsWith('http');
-    });
-    if (!hasDownload) {
-      console.log('  FAIL ' + bpkg + ': no releases with download URLs');
-      failures++;
-      continue;
-    }
-    console.log('  PASS ' + bpkg + ': ' + bdata.releases.length + ' releases');
-    passes++;
-  }
-
-  for (var gi = 0; gi < GITTAG_PKGS.length; gi++) {
-    var gpkg = GITTAG_PKGS[gi];
-    var gfile = Path.join(cachePath, gpkg + '.json');
-    if (!Fs.existsSync(gfile)) {
-      console.log('  FAIL ' + gpkg + ' (gittag): cache file missing');
-      failures++;
-      continue;
-    }
-    var gdata = JSON.parse(Fs.readFileSync(gfile, 'utf8'));
-    if (!gdata.releases || gdata.releases.length === 0) {
-      console.log('  FAIL ' + gpkg + ' (gittag): 0 releases');
-      failures++;
-      continue;
-    }
-    console.log('  PASS ' + gpkg + ' (gittag): ' + gdata.releases.length + ' releases');
-    passes++;
-  }
-
-  // ================================================================
-  // Test 2: Format selection
-  // ================================================================
-  console.log('');
-  console.log('=== Test 2: Format Selection ===');
-  console.log('');
-
-  for (var fi = 0; fi < FORMAT_CASES.length; fi++) {
-    var ftc = FORMAT_CASES[fi];
-    try {
-      var fr = await InstallerServer.helper({
-        unameAgent: ftc.ua,
-        projectName: ftc.pkg,
-        tag: 'stable',
-        formats: ['tar', 'exe', 'zip', 'xz', 'dmg'],
-        libc: '',
-      });
-      var fpkg = fr[0];
-      if (fpkg.channel === 'error') {
-        console.log('  FAIL ' + ftc.label + ': resolved to error');
-        failures++;
-        continue;
-      }
-      if (fpkg.ext !== ftc.expectExt) {
-        console.log('  FAIL ' + ftc.label + ': got .' + fpkg.ext + ' want .' + ftc.expectExt);
-        failures++;
-      } else {
-        console.log('  PASS ' + ftc.label + ': .' + fpkg.ext);
-        passes++;
-      }
-    } catch (e) {
-      console.log('  ERROR ' + ftc.label + ': ' + e.message);
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 3: Edge-case platforms
-  // ================================================================
-  console.log('');
-  console.log('=== Test 3: Edge-Case Platforms ===');
-  console.log('');
-
-  for (var ei = 0; ei < EDGE_CASES.length; ei++) {
-    var etc = EDGE_CASES[ei];
-    try {
-      var er = await InstallerServer.helper({
-        unameAgent: etc.ua,
-        projectName: etc.pkg,
-        tag: 'stable',
-        formats: ['tar', 'exe', 'zip', 'xz', 'dmg'],
-        libc: '',
-      });
-      var epkg = er[0];
-      if (etc.expectNotError && epkg.channel === 'error') {
-        console.log('  FAIL ' + etc.label + ': resolved to error (v' + epkg.version + ')');
-        failures++;
-        continue;
-      }
-      if (etc.expectOs && epkg.os !== etc.expectOs) {
-        console.log('  FAIL ' + etc.label + ': os=' + epkg.os + ' want=' + etc.expectOs);
-        failures++;
-        continue;
-      }
-      console.log('  PASS ' + etc.label + ': v' + epkg.version + ' .' + epkg.ext);
-      passes++;
-    } catch (e) {
-      if (etc.known) {
-        console.log('  KNOWN ' + etc.label + ': ' + e.message);
-        knowns++;
-      } else {
-        console.log('  FAIL ' + etc.label + ': ' + e.message);
-        failures++;
-      }
-    }
-  }
-
-  // ================================================================
-  // Test 4: Script generation smoke tests
-  // ================================================================
-  console.log('');
-  console.log('=== Test 4: Script Generation ===');
-  console.log('');
-
-  for (var si = 0; si < SCRIPT_CASES.length; si++) {
-    var stc = SCRIPT_CASES[si];
-    try {
-      var script = await InstallerServer.serveInstaller(
-        'https://webi.sh',
-        stc.ua,
-        stc.pkg,
-        'stable',
-        'sh',
-        ['tar', 'exe', 'zip', 'xz', 'dmg'],
-        '',
-      );
-
-      // Script must contain WEBI_PKG_URL and WEBI_VERSION
-      var hasUrl = /WEBI_PKG_URL='[^']+'/m.test(script);
-      var hasVersion = /WEBI_VERSION='[^']+'/m.test(script);
-      var hasExt = /WEBI_EXT='[^']+'/m.test(script);
-
-      if (!hasUrl) {
-        console.log('  FAIL ' + stc.label + ': missing WEBI_PKG_URL');
-        failures++;
-      } else if (!hasVersion) {
-        console.log('  FAIL ' + stc.label + ': missing WEBI_VERSION');
-        failures++;
-      } else if (!hasExt) {
-        console.log('  FAIL ' + stc.label + ': missing WEBI_EXT');
-        failures++;
-      } else {
-        var vMatch = script.match(/WEBI_VERSION='([^']+)'/);
-        var extMatch = script.match(/WEBI_EXT='([^']+)'/);
-        console.log('  PASS ' + stc.label + ': v' + vMatch[1] + ' .' + extMatch[1]);
-        passes++;
-      }
-    } catch (e) {
-      console.log('  FAIL ' + stc.label + ': ' + e.message.substring(0, 80));
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 5: API compat — transform-releases vocabulary
-  // ================================================================
-  console.log('');
-  console.log('=== Test 5: API Vocabulary (transform-releases) ===');
-  console.log('');
-
-  for (var ai = 0; ai < API_VOCAB_CASES.length; ai++) {
-    var atc = API_VOCAB_CASES[ai];
-    try {
-      var ares = await Releases.getReleases({
-        pkg: atc.pkg,
-        ver: '',
-        os: '',
-        arch: '',
-        libc: '',
-        lts: false,
-        channel: '',
-        formats: [],
-        limit: 100,
-      });
-      var arels = ares.releases;
-
-      if (atc.expectOses) {
-        var actualOses = [];
-        for (var oi = 0; oi < arels.length; oi++) {
-          if (actualOses.indexOf(arels[oi].os) === -1) {
-            actualOses.push(arels[oi].os);
-          }
-        }
-        actualOses.sort();
-        var missingOses = [];
-        for (var mi = 0; mi < atc.expectOses.length; mi++) {
-          if (actualOses.indexOf(atc.expectOses[mi]) === -1) {
-            missingOses.push(atc.expectOses[mi]);
-          }
-        }
-        if (missingOses.length > 0) {
-          console.log('  FAIL ' + atc.label + ': missing ' + JSON.stringify(missingOses) + ' (has ' + JSON.stringify(actualOses) + ')');
-          failures++;
-        } else {
-          console.log('  PASS ' + atc.label + ': ' + JSON.stringify(atc.expectOses));
-          passes++;
-        }
-      }
-
-      if (atc.expectArches) {
-        var actualArches = [];
-        for (var ari = 0; ari < arels.length; ari++) {
-          if (arels[ari].arch && actualArches.indexOf(arels[ari].arch) === -1) {
-            actualArches.push(arels[ari].arch);
-          }
-        }
-        actualArches.sort();
-        var missingArches = [];
-        for (var mai = 0; mai < atc.expectArches.length; mai++) {
-          if (actualArches.indexOf(atc.expectArches[mai]) === -1) {
-            missingArches.push(atc.expectArches[mai]);
-          }
-        }
-        if (missingArches.length > 0) {
-          console.log('  FAIL ' + atc.label + ': missing ' + JSON.stringify(missingArches) + ' (has ' + JSON.stringify(actualArches) + ')');
-          failures++;
-        } else {
-          console.log('  PASS ' + atc.label);
-          passes++;
-        }
-      }
-    } catch (e) {
-      console.log('  FAIL ' + atc.label + ': ' + e.message);
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 6: Version format
-  // ================================================================
-  console.log('');
-  console.log('=== Test 6: Version Format ===');
-  console.log('');
-
-  // Version format check: the Go cache may have 'v' prefixes (that's OK —
-  // normalize.js and serve-installer.js strip them). What matters is that
-  // after normalization via transform-releases, versions have no 'v' prefix.
-  for (var vi = 0; vi < VERSION_CHECKS.length; vi++) {
-    var vpkg = VERSION_CHECKS[vi];
-    try {
-      var vres = await Releases.getReleases({
-        pkg: vpkg,
-        ver: '',
-        os: '',
-        arch: '',
-        libc: '',
-        lts: false,
-        channel: '',
-        formats: [],
-        limit: 10,
-      });
-      var vrels = vres.releases;
-      var badVersions = [];
-      for (var vri = 0; vri < vrels.length; vri++) {
-        var ver = vrels[vri].version;
-        if (!ver) {
-          badVersions.push('(empty)');
-          break;
-        }
-        if (ver.startsWith('v')) {
-          badVersions.push(ver);
-          break;
-        }
-      }
-      if (badVersions.length > 0) {
-        console.log('  FAIL ' + vpkg + ': v-prefix not stripped: ' + badVersions[0]);
-        failures++;
-      } else {
-        console.log('  PASS ' + vpkg + ': latest=' + (vrels[0] ? vrels[0].version : '?'));
-        passes++;
-      }
-    } catch (e) {
-      console.log('  FAIL ' + vpkg + ': ' + e.message);
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 7: Channel detection
-  // ================================================================
-  console.log('');
-  console.log('=== Test 7: Channel Detection ===');
-  console.log('');
-
-  for (var ci = 0; ci < CHANNEL_CASES.length; ci++) {
-    var ctc = CHANNEL_CASES[ci];
-    try {
-      var cres = await Releases.getReleases({
-        pkg: ctc.pkg,
-        ver: '',
-        os: '',
-        arch: '',
-        libc: '',
-        lts: false,
-        channel: ctc.channel,
-        formats: [],
-        limit: 100,
-      });
-      var count = cres.releases.length;
-      if (count < ctc.expectMinCount) {
-        console.log('  FAIL ' + ctc.label + ': only ' + count + ' (want >=' + ctc.expectMinCount + ')');
-        failures++;
-      } else {
-        console.log('  PASS ' + ctc.label + ': ' + count + ' releases');
-        passes++;
-      }
-    } catch (e) {
-      console.log('  FAIL ' + ctc.label + ': ' + e.message);
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Summary
-  // ================================================================
-  console.log('');
-  console.log('=== Results: ' + passes + ' passed, ' + failures + ' failed, ' + knowns + ' known, ' + skips + ' skipped ===');
-  if (failures > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-fleet-diff.js

@@ -1,339 +0,0 @@
-'use strict';
-
-// Fleet-wide diff: compare a candidate host (e.g. beta.webi.sh) against
-// production for every cached package, across multiple OS/arch combos.
-// Outputs TSV for grep/sort.
-//
-// Usage:
-//   node _webi/test-fleet-diff.js
-//     --cand-url=https://beta.webi.sh
-//     --prod-url=https://webinstall.dev      # default
-//     --kind=api                             # default; or "installer"
-//     --pkgs=bat,go,...                      # default: all cached packages
-//     --concurrency=8                        # default
-//     --out=fleet-api.tsv                    # default: stdout
-
-let Fs = require('node:fs/promises');
-let Os = require('node:os');
-let Path = require('node:path');
-let Https = require('node:https');
-
-let CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-
-function arg(name, dflt) {
-  for (let a of process.argv) {
-    if (a.startsWith(`--${name}=`)) {
-      return a.slice(name.length + 3);
-    }
-  }
-  return dflt;
-}
-
-let CAND_URL = arg('cand-url', 'https://beta.webi.sh').replace(/\/+$/, '');
-let PROD_URL = arg('prod-url', 'https://webinstall.dev').replace(/\/+$/, '');
-let KIND = arg('kind', 'api');
-let PKGS_ARG = arg('pkgs', '');
-let CONCURRENCY = parseInt(arg('concurrency', '8'), 10);
-let OUT = arg('out', '');
-
-// OS/arch matrix for API mode
-let API_MATRIX = [
-  { os: 'macos', arch: 'amd64' },
-  { os: 'macos', arch: 'arm64' },
-  { os: 'linux', arch: 'amd64' },
-  { os: 'linux', arch: 'arm64' },
-  { os: 'linux', arch: 'armv7l' },
-  { os: 'windows', arch: 'amd64' },
-  { os: 'freebsd', arch: 'amd64' },
-];
-
-// UA strings for installer mode
-let INSTALLER_MATRIX = [
-  { label: 'macos_arm64', ua: 'aarch64/unknown Darwin/24.2.0 libc' },
-  { label: 'macos_amd64', ua: 'x86_64/unknown Darwin/23.0.0 libc' },
-  { label: 'linux_amd64', ua: 'x86_64/unknown Linux/5.15.0 libc' },
-  { label: 'linux_arm64', ua: 'aarch64/unknown Linux/5.15.0 libc' },
-  { label: 'linux_musl', ua: 'x86_64/unknown Linux/5.15.0 musl' },
-  { label: 'windows_amd64', ua: 'x86_64/unknown Windows/10.0.19041 msvc' },
-];
-
-function httpsGet(url, headers) {
-  return new Promise(function (resolve, reject) {
-    let opts = { headers: headers || {}, timeout: 15000 };
-    let req = Https.get(url, opts, function (res) {
-      // Follow one redirect
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        let redir = res.headers.location;
-        if (redir.startsWith('/')) {
-          let m = url.match(/^(https?:\/\/[^/]+)/);
-          redir = (m ? m[1] : '') + redir;
-        }
-        Https.get(redir, opts, function (res2) {
-          let data = '';
-          res2.on('data', function (c) { data += c; });
-          res2.on('end', function () { resolve({ status: res2.statusCode, body: data }); });
-        }).on('error', reject);
-        return;
-      }
-      let data = '';
-      res.on('data', function (c) { data += c; });
-      res.on('end', function () { resolve({ status: res.statusCode, body: data }); });
-    });
-    req.on('error', reject);
-    req.on('timeout', function () { req.destroy(new Error('timeout')); });
-  });
-}
-
-async function listCachedPkgs() {
-  let entries = await Fs.readdir(CACHE_DIR);
-  return entries
-    .filter(function (n) { return n.endsWith('.json') && !n.endsWith('.updated.txt'); })
-    .map(function (n) { return n.slice(0, -5); })
-    .sort();
-}
-
-function safeFirst(json) {
-  try {
-    let arr = JSON.parse(json);
-    if (!Array.isArray(arr) || arr.length === 0) {
-      return null;
-    }
-    return arr[0];
-  } catch (e) {
-    return null;
-  }
-}
-
-function parseInstallerVars(script) {
-  let vars = {};
-  let re = /^(?:export\s+)?(WEBI_\w+|PKG_NAME)='([^']*)'/gm;
-  let m;
-  while ((m = re.exec(script)) !== null) {
-    vars[m[1]] = m[2];
-  }
-  return vars;
-}
-
-async function diffApi(pkg, os, arch) {
-  let qs = `?os=${os}&arch=${arch}&limit=1`;
-  let candUrl = `${CAND_URL}/api/releases/${pkg}@stable.json${qs}`;
-  let prodUrl = `${PROD_URL}/api/releases/${pkg}@stable.json${qs}`;
-
-  let cand, prod;
-  try {
-    [cand, prod] = await Promise.all([httpsGet(candUrl), httpsGet(prodUrl)]);
-  } catch (e) {
-    return { pkg, os, arch, status: 'fetch_error', detail: e.message };
-  }
-
-  if (cand.status !== 200 || prod.status !== 200) {
-    return {
-      pkg, os, arch, status: 'http_error',
-      detail: `cand=${cand.status} prod=${prod.status}`,
-    };
-  }
-
-  let candFirst = safeFirst(cand.body);
-  let prodFirst = safeFirst(prod.body);
-
-  let candErr = !candFirst || candFirst.channel === 'error';
-  let prodErr = !prodFirst || prodFirst.channel === 'error';
-
-  if (candErr && prodErr) {
-    return { pkg, os, arch, status: 'both_error', detail: '' };
-  }
-  if (candErr && !prodErr) {
-    return {
-      pkg, os, arch, status: 'cand_only_error',
-      detail: `prod=${prodFirst.version}/${prodFirst.ext}`,
-    };
-  }
-  if (!candErr && prodErr) {
-    return {
-      pkg, os, arch, status: 'prod_only_error',
-      detail: `cand=${candFirst.version}/${candFirst.ext}`,
-    };
-  }
-
-  // Both succeeded — diff the key fields
-  let diffs = [];
-  for (let f of ['os', 'arch', 'libc', 'ext']) {
-    if (candFirst[f] !== prodFirst[f]) {
-      diffs.push(`${f}:cand=${candFirst[f]}|prod=${prodFirst[f]}`);
-    }
-  }
-
-  let ver = candFirst.version === prodFirst.version
-    ? candFirst.version
-    : `cand=${candFirst.version}|prod=${prodFirst.version}`;
-
-  return {
-    pkg, os, arch,
-    status: diffs.length === 0 ? 'match' : 'diff',
-    detail: diffs.length === 0 ? `v${ver} ${candFirst.ext}` : `v${ver} ${diffs.join(',')}`,
-  };
-}
-
-async function diffInstaller(pkg, label, ua) {
-  let candUrl = `${CAND_URL}/api/installers/${pkg}@stable.sh`;
-  let prodUrl = `${PROD_URL}/api/installers/${pkg}@stable.sh`;
-  let headers = { 'User-Agent': ua };
-
-  let cand, prod;
-  try {
-    [cand, prod] = await Promise.all([
-      httpsGet(candUrl, headers),
-      httpsGet(prodUrl, headers),
-    ]);
-  } catch (e) {
-    return { pkg, label, status: 'fetch_error', detail: e.message };
-  }
-
-  if (cand.status !== 200 || prod.status !== 200) {
-    return {
-      pkg, label, status: 'http_error',
-      detail: `cand=${cand.status} prod=${prod.status}`,
-    };
-  }
-
-  let candVars = parseInstallerVars(cand.body);
-  let prodVars = parseInstallerVars(prod.body);
-
-  let candHas = candVars.WEBI_PKG_URL && candVars.WEBI_EXT && candVars.WEBI_EXT !== 'err';
-  let prodHas = prodVars.WEBI_PKG_URL && prodVars.WEBI_EXT && prodVars.WEBI_EXT !== 'err';
-
-  if (!candHas && !prodHas) {
-    return { pkg, label, status: 'both_error', detail: '' };
-  }
-  if (!candHas && prodHas) {
-    return {
-      pkg, label, status: 'cand_only_error',
-      detail: `prod=${prodVars.WEBI_VERSION}/${prodVars.WEBI_EXT}`,
-    };
-  }
-  if (candHas && !prodHas) {
-    return {
-      pkg, label, status: 'prod_only_error',
-      detail: `cand=${candVars.WEBI_VERSION}/${candVars.WEBI_EXT}`,
-    };
-  }
-
-  // Diff WEBI_OS, WEBI_ARCH, WEBI_EXT (PKG_NAME may differ for aliases)
-  let diffs = [];
-  for (let v of ['WEBI_OS', 'WEBI_ARCH', 'WEBI_EXT']) {
-    if (candVars[v] !== prodVars[v]) {
-      diffs.push(`${v}:cand=${candVars[v]}|prod=${prodVars[v]}`);
-    }
-  }
-
-  let ver = candVars.WEBI_VERSION === prodVars.WEBI_VERSION
-    ? candVars.WEBI_VERSION
-    : `cand=${candVars.WEBI_VERSION}|prod=${prodVars.WEBI_VERSION}`;
-
-  return {
-    pkg, label,
-    status: diffs.length === 0 ? 'match' : 'diff',
-    detail: diffs.length === 0 ? `v${ver} ${candVars.WEBI_EXT}` : `v${ver} ${diffs.join(',')}`,
-  };
-}
-
-async function pool(items, fn, concurrency) {
-  let results = new Array(items.length);
-  let i = 0;
-  async function worker() {
-    while (true) {
-      let idx = i++;
-      if (idx >= items.length) {
-        return;
-      }
-      try {
-        results[idx] = await fn(items[idx], idx);
-      } catch (e) {
-        results[idx] = { status: 'exception', detail: e.message, _item: items[idx] };
-      }
-    }
-  }
-  let workers = [];
-  for (let k = 0; k < concurrency; k++) {
-    workers.push(worker());
-  }
-  await Promise.all(workers);
-  return results;
-}
-
-async function main() {
-  let pkgs;
-  if (PKGS_ARG) {
-    pkgs = PKGS_ARG.split(',').filter(Boolean);
-  } else {
-    pkgs = await listCachedPkgs();
-  }
-
-  console.error(`Comparing ${pkgs.length} packages: ${CAND_URL} (cand) vs ${PROD_URL} (prod)`);
-  console.error(`Mode: ${KIND}, concurrency: ${CONCURRENCY}`);
-
-  let jobs = [];
-  if (KIND === 'api') {
-    for (let pkg of pkgs) {
-      for (let combo of API_MATRIX) {
-        jobs.push({ pkg, os: combo.os, arch: combo.arch });
-      }
-    }
-  } else if (KIND === 'installer') {
-    for (let pkg of pkgs) {
-      for (let combo of INSTALLER_MATRIX) {
-        jobs.push({ pkg, label: combo.label, ua: combo.ua });
-      }
-    }
-  } else {
-    console.error(`Unknown kind: ${KIND}`);
-    process.exit(2);
-  }
-
-  let started = Date.now();
-  let results = await pool(jobs, async function (job) {
-    if (KIND === 'api') {
-      return diffApi(job.pkg, job.os, job.arch);
-    }
-    return diffInstaller(job.pkg, job.label, job.ua);
-  }, CONCURRENCY);
-  let elapsed = ((Date.now() - started) / 1000).toFixed(1);
-
-  // TSV output
-  let lines = [];
-  if (KIND === 'api') {
-    lines.push(['pkg', 'os', 'arch', 'status', 'detail'].join('\t'));
-    for (let r of results) {
-      lines.push([r.pkg, r.os, r.arch, r.status, r.detail || ''].join('\t'));
-    }
-  } else {
-    lines.push(['pkg', 'target', 'status', 'detail'].join('\t'));
-    for (let r of results) {
-      lines.push([r.pkg, r.label, r.status, r.detail || ''].join('\t'));
-    }
-  }
-  let body = lines.join('\n') + '\n';
-
-  if (OUT) {
-    await Fs.writeFile(OUT, body, 'utf8');
-    console.error(`Wrote ${OUT}`);
-  } else {
-    process.stdout.write(body);
-  }
-
-  // Summary to stderr
-  let counts = {};
-  for (let r of results) {
-    counts[r.status] = (counts[r.status] || 0) + 1;
-  }
-  console.error('');
-  console.error(`=== Summary (${elapsed}s, ${results.length} jobs) ===`);
-  for (let s of Object.keys(counts).sort()) {
-    console.error(`  ${s}: ${counts[s]}`);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-installer-resolve.js

@@ -1,444 +0,0 @@
-'use strict';
-
-let InstallerServer = require('./serve-installer.js');
-let Builds = require('./builds.js');
-
-// Real User-Agent strings sent by webi bootstrap scripts.
-//
-// Libc taxonomy:
-//   none = static build, no runtime libc dep (often built with musl, but self-contained)
-//   musl = requires musl C/C++ runtime at runtime (e.g. node-musl)
-//   gnu  = requires glibc at runtime (crashes on musl-only/Alpine)
-//   libc = host UA value meaning "I have glibc" (not used in release metadata)
-//
-// Known issues:
-//
-// 1. WATERFALL libc vs gnu: The WATERFALL maps `libc` => ['none', 'libc']
-//    but never tries 'gnu'. Packages with glibc-linked builds (libc='gnu' in
-//    Go cache) won't match for hosts reporting 'libc'. Fix: update WATERFALL
-//    to `libc: ['none', 'gnu', 'libc']` in build-classifier submodule.
-//
-// 2. Go cache .git regression: The Go cache includes .git source repo URLs
-//    as releases, creating ANYOS/ANYARCH triplets. These match before
-//    platform-specific binaries. Fix: exclude .git from Go cache output.
-
-let UA_CASES = [
-  // === macOS (no libc issue — darwin uses libc='none') ===
-  {
-    label: 'bat macOS arm64',
-    pkg: 'bat',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'bat macOS amd64',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Darwin/23.0.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'go macOS arm64',
-    pkg: 'go',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'node macOS arm64',
-    pkg: 'node',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'tar.xz',
-  },
-  {
-    label: 'rg macOS arm64',
-    pkg: 'rg',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'tar.gz',
-  },
-
-  // === macOS universal2 — packages where recent darwin builds are universal-only ===
-  // These currently resolve to ancient versions because universal2 entries are
-  // dropped by the classifier. The GOER's legacy export needs to emit these
-  // with arch: "x86_64" so the classifier accepts them. The darwin WATERFALL
-  // (aarch64 falls back to x86_64) handles aarch64 users.
-  {
-    label: 'cmake macOS arm64 (universal2)',
-    pkg: 'cmake',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectExt: 'tar.gz',
-    expectMinVersion: '4.0.0',
-    known: true,
-  },
-  {
-    label: 'cmake macOS amd64 (universal2)',
-    pkg: 'cmake',
-    ua: 'x86_64/unknown Darwin/23.0.0 libc',
-    expectOs: 'darwin',
-    expectExt: 'tar.gz',
-    expectMinVersion: '4.0.0',
-    known: true,
-  },
-  {
-    label: 'hugo macOS arm64 (universal2)',
-    pkg: 'hugo',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectExt: 'tar.gz',
-    expectMinVersion: '0.140.0',
-    known: true,
-  },
-  {
-    label: 'hugo macOS amd64 (universal2)',
-    pkg: 'hugo',
-    ua: 'x86_64/unknown Darwin/23.0.0 libc',
-    expectOs: 'darwin',
-    expectExt: 'tar.gz',
-    expectMinVersion: '0.140.0',
-    known: true,
-  },
-
-  // === Windows ===
-  {
-    label: 'bat Windows amd64',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Windows/10.0.19041 msvc',
-    expectOs: 'windows',
-    expectArch: 'x86_64',
-    expectExt: 'zip',
-  },
-  {
-    label: 'go Windows amd64',
-    pkg: 'go',
-    ua: 'x86_64/unknown Windows/10.0.19041 msvc',
-    expectOs: 'windows',
-    expectArch: 'x86_64',
-    expectExt: 'zip',
-  },
-
-  // === Linux musl (Alpine/Docker) ===
-  {
-    label: 'bat Linux musl',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Linux/5.15.0 musl',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-
-  // === Linux glibc — packages with libc='none' in cache ===
-  {
-    label: 'go Linux amd64',
-    pkg: 'go',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-  // === Linux glibc — packages with libc='gnu' in cache ===
-  // These previously failed (WATERFALL libc→gnu gap). Fixed by adding
-  // 'gnu' to the libc candidates for glibc hosts in _enumerateTriplets.
-  {
-    label: 'bat Linux amd64',
-    pkg: 'bat',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'rg Linux amd64',
-    pkg: 'rg',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'node Linux amd64',
-    pkg: 'node',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.xz',
-  },
-
-  // === Packages with .git source URLs in old releases ===
-  // These previously failed (ANYOS .git matched before platform binary).
-  // Fixed by putting specific OS before ANYOS in triplet enumeration.
-  {
-    label: 'jq macOS arm64',
-    pkg: 'jq',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'exe',
-  },
-  {
-    label: 'caddy macOS arm64',
-    pkg: 'caddy',
-    ua: 'aarch64/unknown Darwin/24.2.0 libc',
-    expectOs: 'darwin',
-    expectArch: 'aarch64',
-    expectExt: 'tar.gz',
-  },
-  {
-    label: 'caddy Linux amd64',
-    pkg: 'caddy',
-    ua: 'x86_64/unknown Linux/5.15.0 libc',
-    expectOs: 'linux',
-    expectArch: 'x86_64',
-    expectExt: 'tar.gz',
-  },
-];
-
-async function main() {
-  let failures = 0;
-  let passes = 0;
-  let knowns = 0;
-  let errors = 0;
-
-  console.log('Initializing build cache...');
-  await Builds.init();
-  console.log('');
-
-  console.log('=== Installer Resolution Tests ===');
-  console.log('');
-
-  for (let tc of UA_CASES) {
-    try {
-      let [pkg, params] = await InstallerServer.helper({
-        unameAgent: tc.ua,
-        projectName: tc.pkg,
-        tag: 'stable',
-        formats: ['tar', 'exe', 'zip', 'xz', 'dmg'],
-        libc: '',
-      });
-
-      // Known issue — just verify it fails as expected
-      if (tc.known) {
-        let isError = pkg.channel === 'error' || !pkg.download || pkg.download.includes('doesntexist') || pkg.ext === 'git';
-        let isStale = false;
-        if (tc.expectMinVersion && pkg.version) {
-          let got = pkg.version.replace(/^v/, '').split('.').map(Number);
-          let want = tc.expectMinVersion.split('.').map(Number);
-          for (let i = 0; i < want.length; i++) {
-            if ((got[i] || 0) < want[i]) { isStale = true; break; }
-            if ((got[i] || 0) > want[i]) { break; }
-          }
-        }
-        if (isError || isStale) {
-          let detail = isStale ? `stale v${pkg.version} < v${tc.expectMinVersion}` : '';
-          console.log(`  KNOWN ${tc.label}${detail ? ': ' + detail : ''}`);
-          knowns++;
-        } else {
-          console.log(`  PASS ${tc.label} (known issue resolved!): v${pkg.version} .${pkg.ext} ${(pkg.download || '').split('/').pop()}`);
-          passes++;
-        }
-        continue;
-      }
-
-      if (pkg.channel === 'error') {
-        console.log(`  FAIL ${tc.label}: resolved to error package`);
-        failures++;
-        continue;
-      }
-
-      let diffs = [];
-
-      if (tc.expectOs && pkg.os !== tc.expectOs) {
-        diffs.push(`os: got=${pkg.os} want=${tc.expectOs}`);
-      }
-      if (tc.expectArch && pkg.arch !== tc.expectArch) {
-        diffs.push(`arch: got=${pkg.arch} want=${tc.expectArch}`);
-      }
-      if (tc.expectExt && pkg.ext !== tc.expectExt) {
-        diffs.push(`ext: got=${pkg.ext} want=${tc.expectExt}`);
-      }
-
-      if (!pkg.version || pkg.version === '0.0.0') {
-        diffs.push('version: missing or zero');
-      }
-
-      if (!pkg.download || pkg.download.includes('doesntexist')) {
-        diffs.push('download: missing or error');
-      }
-
-      if (diffs.length > 0) {
-        console.log(`  FAIL ${tc.label}: ${diffs.join(', ')}`);
-        failures++;
-      } else {
-        console.log(`  PASS ${tc.label}: v${pkg.version} .${pkg.ext} ${pkg.download.split('/').pop()}`);
-        passes++;
-      }
-    } catch (err) {
-      if (tc.known) {
-        console.log(`  KNOWN ${tc.label} (error: ${err.message})`);
-        knowns++;
-        continue;
-      }
-      console.log(`  ERROR ${tc.label}: ${err.message}`);
-      errors++;
-    }
-  }
-
-  console.log('');
-  console.log(`=== Results: ${passes} passed, ${failures} failed, ${knowns} known, ${errors} errors ===`);
-  if (failures > 0 || errors > 0) {
-    process.exit(1);
-  }
-
-  // Cache value validation: the classifier re-parses filenames and rejects
-  // entries where the cache os/arch doesn't match. These checks prevent
-  // regressions where someone "normalizes" cache values in a way that
-  // breaks the classifier.
-  console.log('');
-  console.log('=== Cache Value Validation ===');
-  console.log('');
-  let cacheFailures = await validateCacheValues();
-  if (cacheFailures > 0) {
-    process.exit(1);
-  }
-}
-
-// Verify that cache os/arch values match what the Node classifier expects
-// to extract from the download filename. The classifier is a submodule and
-// is NOT being modified — the cache must emit values it already recognizes.
-//
-// Known bug (LIVE_cache): the Go legacy export previously translated
-// solaris/illumos → sunos in the cache, but the filenames still say
-// solaris/illumos. The classifier detects the filename value and rejects
-// the entry when it doesn't match. Same issue with universal2 arch.
-//
-// Rule: cache os/arch must match the filename, not some "canonical" form.
-
-// Cache os/arch values must match what the Node classifier extracts from the
-// download filename. The classifier already recognizes solaris, illumos, sunos,
-// armhf, armel, etc. — these are not new values. The only value the classifier
-// does NOT recognize is "universal2" — use "x86_64" instead.
-//
-// matchField: which field to check in the release entry ('name' or 'download')
-let CACHE_CHECKS = [
-  // The classifier knows "solaris" as an OS. Filenames/URLs say "solaris".
-  // Do NOT translate to "sunos" — that creates a mismatch and drops the entry.
-  {
-    label: 'terraform solaris entries have os=solaris (not sunos)',
-    pkg: 'terraform',
-    matchField: 'download',
-    filenameMatch: /solaris/,
-    field: 'os',
-    expect: 'solaris',
-  },
-  {
-    label: 'syncthing solaris entries have os=solaris (not sunos)',
-    pkg: 'syncthing',
-    matchField: 'download',
-    filenameMatch: /solaris/,
-    field: 'os',
-    expect: 'solaris',
-  },
-  // The classifier knows "illumos" as an OS. Don't translate to sunos.
-  {
-    label: 'syncthing illumos entries have os=illumos (not sunos)',
-    pkg: 'syncthing',
-    matchField: 'download',
-    filenameMatch: /illumos/,
-    field: 'os',
-    expect: 'illumos',
-  },
-  // node.js uses "sunos" in filenames — cache must say "sunos" (already correct)
-  {
-    label: 'node sunos entries have os=sunos',
-    pkg: 'node',
-    matchField: 'name',
-    filenameMatch: /sunos/,
-    field: 'os',
-    expect: 'sunos',
-  },
-  // The classifier maps "universal" in filenames → x86_64. The classifier does
-  // NOT recognize "universal2". Cache must say arch="x86_64" for these entries.
-  // aarch64 users get them via the darwin WATERFALL (aarch64 → x86_64 fallback).
-  {
-    label: 'cmake universal entries have arch=x86_64 (not universal2)',
-    pkg: 'cmake',
-    matchField: 'download',
-    filenameMatch: /universal/,
-    field: 'arch',
-    expect: 'x86_64',
-  },
-  {
-    label: 'hugo universal entries have arch=x86_64 (not universal2)',
-    pkg: 'hugo',
-    matchField: 'download',
-    filenameMatch: /universal/,
-    field: 'arch',
-    expect: 'x86_64',
-  },
-];
-
-async function validateCacheValues() {
-  let Os = require('node:os');
-  let Path = require('path');
-  let Fs = require('fs');
-
-  let cachePath = Path.join(Os.homedir(), '.cache/webi/legacy');
-  if (!Fs.existsSync(cachePath)) {
-    console.log('  SKIP: no cache directory at ' + cachePath);
-    return 0;
-  }
-
-  let failures = 0;
-
-  for (let check of CACHE_CHECKS) {
-    let filePath = Path.join(cachePath, `${check.pkg}.json`);
-    if (!Fs.existsSync(filePath)) {
-      console.log(`  SKIP ${check.label}: no cache file`);
-      continue;
-    }
-
-    let data = JSON.parse(Fs.readFileSync(filePath, 'utf8'));
-    let matchField = check.matchField || 'name';
-    let matched = data.releases.filter(function (r) {
-      return check.filenameMatch.test(r[matchField]);
-    });
-
-    if (matched.length === 0) {
-      console.log(`  SKIP ${check.label}: no matching filenames`);
-      continue;
-    }
-
-    let wrong = matched.filter(function (r) {
-      return r[check.field] !== check.expect;
-    });
-
-    if (wrong.length > 0) {
-      let sample = wrong[0];
-      console.log(
-        `  FAIL ${check.label}: ${wrong.length}/${matched.length} entries have` +
-        ` ${check.field}="${sample[check.field]}" (want "${check.expect}")` +
-        ` e.g. ${sample.name}`,
-      );
-      failures++;
-    } else {
-      console.log(`  PASS ${check.label}: ${matched.length} entries OK`);
-    }
-  }
-
-  console.log('');
-  console.log(`=== Cache Validation: ${CACHE_CHECKS.length - failures} passed, ${failures} failed ===`);
-  return failures;
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-live-cache-diff.js

@@ -1,450 +0,0 @@
-'use strict';
-
-// Compare _cache vs LIVE_cache for correctness and compatibility.
-//
-// Rules (from NODER_PURPOSE.md):
-//   - _cache should be more complete and more correct than LIVE_cache
-//   - Must NOT introduce new tags (OS, arch, libc) that don't exist in LIVE_cache
-//   - Must NOT break compatibility with existing data
-//
-// Usage: node _webi/test-live-cache-diff.js
-
-var Fs = require('node:fs');
-var Os = require('node:os');
-var Path = require('node:path');
-
-// CACHE_DIR is the live cache produced by webicached (flat layout).
-// LIVE_DIR is the historical snapshot taken pre-cutover (month-bucketed).
-var CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-var LIVE_DIR = Path.join(__dirname, '..', 'LIVE_cache');
-
-// resolveLayout: figures out whether dir uses the flat layout
-// (~/.cache/webi/legacy/<pkg>.json) or the legacy month-bucketed layout
-// (LIVE_cache/<YYYY-MM>/<pkg>.json) and returns the directory to read from.
-function resolveLayout(dir) {
-  if (!Fs.existsSync(dir)) {
-    return null;
-  }
-  var entries = Fs.readdirSync(dir);
-  var months = entries
-    .filter(function (d) { return /^\d{4}-\d{2}$/.test(d); })
-    .sort()
-    .reverse();
-  if (months[0]) {
-    return Path.join(dir, months[0]);
-  }
-  // Flat layout (cache files directly under dir).
-  return dir;
-}
-
-function loadReleases(layoutPath, pkg) {
-  var file = Path.join(layoutPath, pkg + '.json');
-  if (!Fs.existsSync(file)) {
-    return null;
-  }
-  try {
-    return JSON.parse(Fs.readFileSync(file, 'utf8'));
-  } catch (e) {
-    return null;
-  }
-}
-
-function uniqueValues(releases, field) {
-  var seen = {};
-  for (var i = 0; i < releases.length; i++) {
-    var val = releases[i][field];
-    if (val !== null && val !== undefined && val !== '') {
-      seen[val] = true;
-    }
-  }
-  return Object.keys(seen).sort();
-}
-
-async function main() {
-  var passes = 0;
-  var failures = 0;
-  var warns = 0;
-
-  var cachePath = resolveLayout(CACHE_DIR);
-  var livePath = resolveLayout(LIVE_DIR);
-
-  if (!cachePath) {
-    console.error('No _cache directory found');
-    process.exit(1);
-  }
-  if (!livePath) {
-    console.error('No LIVE_cache directory found');
-    process.exit(1);
-  }
-
-  console.log('Using cache: ' + cachePath + ' vs ' + livePath);
-  console.log('');
-
-  // Get all packages that exist in both caches
-  var cacheFiles = Fs.readdirSync(cachePath)
-    .filter(function (f) { return f.endsWith('.json'); })
-    .map(function (f) { return f.replace('.json', ''); });
-  var liveFiles = Fs.readdirSync(livePath)
-    .filter(function (f) { return f.endsWith('.json'); })
-    .map(function (f) { return f.replace('.json', ''); });
-
-  var cacheSet = {};
-  var liveSet = {};
-  cacheFiles.forEach(function (f) { cacheSet[f] = true; });
-  liveFiles.forEach(function (f) { liveSet[f] = true; });
-
-  var common = cacheFiles.filter(function (f) { return liveSet[f]; });
-
-  // ================================================================
-  // Test 1: Global vocabulary — no new OS/arch/libc tags
-  // ================================================================
-  console.log('=== Test 1: No New Tags (OS/Arch/Libc) ===');
-  console.log('');
-
-  var allLiveOs = {};
-  var allLiveArch = {};
-  var allLiveLibc = {};
-  var allCacheOs = {};
-  var allCacheArch = {};
-  var allCacheLibc = {};
-
-  for (var ci = 0; ci < common.length; ci++) {
-    var pkg = common[ci];
-    var liveData = loadReleases(livePath, pkg);
-    var cacheData = loadReleases(cachePath, pkg);
-    if (!liveData || !cacheData) { continue; }
-
-    uniqueValues(liveData.releases, 'os').forEach(function (v) { allLiveOs[v] = true; });
-    uniqueValues(liveData.releases, 'arch').forEach(function (v) { allLiveArch[v] = true; });
-    uniqueValues(liveData.releases, 'libc').forEach(function (v) { allLiveLibc[v] = true; });
-    uniqueValues(cacheData.releases, 'os').forEach(function (v) { allCacheOs[v] = true; });
-    uniqueValues(cacheData.releases, 'arch').forEach(function (v) { allCacheArch[v] = true; });
-    uniqueValues(cacheData.releases, 'libc').forEach(function (v) { allCacheLibc[v] = true; });
-  }
-
-  var newOs = Object.keys(allCacheOs).filter(function (v) { return !allLiveOs[v]; }).sort();
-  var newArch = Object.keys(allCacheArch).filter(function (v) { return !allLiveArch[v]; }).sort();
-  var newLibc = Object.keys(allCacheLibc).filter(function (v) { return !allLiveLibc[v]; }).sort();
-
-  if (newOs.length > 0) {
-    console.log('  FAIL new OS values in _cache not in LIVE_cache: ' + JSON.stringify(newOs));
-    failures++;
-  } else {
-    console.log('  PASS no new OS values');
-    passes++;
-  }
-
-  if (newArch.length > 0) {
-    console.log('  FAIL new arch values in _cache not in LIVE_cache: ' + JSON.stringify(newArch));
-    failures++;
-  } else {
-    console.log('  PASS no new arch values');
-    passes++;
-  }
-
-  if (newLibc.length > 0) {
-    console.log('  FAIL new libc values in _cache not in LIVE_cache: ' + JSON.stringify(newLibc));
-    failures++;
-  } else {
-    console.log('  PASS no new libc values');
-    passes++;
-  }
-
-  // Show what LIVE has that _cache doesn't (informational)
-  var missingOs = Object.keys(allLiveOs).filter(function (v) { return !allCacheOs[v]; }).sort();
-  var missingArch = Object.keys(allLiveArch).filter(function (v) { return !allCacheArch[v]; }).sort();
-  if (missingOs.length > 0) {
-    console.log('  INFO OS in LIVE but not _cache: ' + JSON.stringify(missingOs));
-  }
-  if (missingArch.length > 0) {
-    console.log('  INFO arch in LIVE but not _cache: ' + JSON.stringify(missingArch));
-  }
-
-  // ================================================================
-  // Test 2: Per-package release count — _cache should have >= LIVE
-  // ================================================================
-  console.log('');
-  console.log('=== Test 2: Release Count (per package) ===');
-  console.log('');
-
-  // LIVE_cache includes junk entries (.pem, .sig, .sha256, .deb, .rpm, etc.)
-  // that Go correctly filters out. Only count installable entries.
-  var junkExts = /\.(pem|sig|asc|sha256|sha512|sha256sum|sha512sum|deb|rpm|apk|sbom|json|txt|sum|md5|cosign-bundle|intoto-jsonl)$/i;
-
-  function countInstallable(releases) {
-    var n = 0;
-    for (var i = 0; i < releases.length; i++) {
-      if (!junkExts.test(releases[i].name || '')) {
-        n++;
-      }
-    }
-    return n;
-  }
-
-  var countIssues = [];
-  for (var pi = 0; pi < common.length; pi++) {
-    var ppkg = common[pi];
-    var pLive = loadReleases(livePath, ppkg);
-    var pCache = loadReleases(cachePath, ppkg);
-    if (!pLive || !pCache) { continue; }
-
-    var liveCount = countInstallable(pLive.releases);
-    var cacheCount = pCache.releases.length;
-
-    // _cache should have at least as many installable releases as LIVE
-    var ratio = liveCount > 0 ? cacheCount / liveCount : 1;
-    if (ratio < 0.5 && liveCount > 10) {
-      countIssues.push({ pkg: ppkg, live: liveCount, cache: cacheCount, ratio: ratio });
-    }
-  }
-
-  if (countIssues.length === 0) {
-    console.log('  PASS all packages have adequate release counts');
-    passes++;
-  } else {
-    for (var ii = 0; ii < countIssues.length; ii++) {
-      var issue = countIssues[ii];
-      console.log('  FAIL ' + issue.pkg + ': _cache=' + issue.cache + ' LIVE=' + issue.live + ' (ratio=' + issue.ratio.toFixed(2) + ')');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 3: Per-package OS coverage — _cache should have same core OSes
-  // ================================================================
-  console.log('');
-  console.log('=== Test 3: OS Coverage (per package) ===');
-  console.log('');
-
-  var coreOses = ['darwin', 'linux', 'windows'];
-  var osIssues = [];
-  for (var oi = 0; oi < common.length; oi++) {
-    var opkg = common[oi];
-    var oLive = loadReleases(livePath, opkg);
-    var oCache = loadReleases(cachePath, opkg);
-    if (!oLive || !oCache) { continue; }
-
-    var liveOses = uniqueValues(oLive.releases, 'os');
-    var cacheOses = uniqueValues(oCache.releases, 'os');
-
-    // For each core OS in LIVE, it should also be in _cache
-    for (var coi = 0; coi < coreOses.length; coi++) {
-      var os = coreOses[coi];
-      if (liveOses.indexOf(os) >= 0 && cacheOses.indexOf(os) < 0) {
-        osIssues.push({ pkg: opkg, os: os });
-      }
-    }
-  }
-
-  if (osIssues.length === 0) {
-    console.log('  PASS all packages have matching core OS coverage');
-    passes++;
-  } else {
-    for (var oii = 0; oii < osIssues.length; oii++) {
-      var oisue = osIssues[oii];
-      console.log('  FAIL ' + oisue.pkg + ': missing os=' + oisue.os + ' (present in LIVE)');
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 4: Per-package new tags — flag packages introducing new values
-  // ================================================================
-  console.log('');
-  console.log('=== Test 4: Per-Package New Tags ===');
-  console.log('');
-
-  var tagIssues = [];
-  var tagSkipped = 0;
-  for (var ti = 0; ti < common.length; ti++) {
-    var tpkg = common[ti];
-    var tLive = loadReleases(livePath, tpkg);
-    var tCache = loadReleases(cachePath, tpkg);
-    if (!tLive || !tCache) { continue; }
-
-    var tLiveOs = {};
-    var tLiveArch = {};
-    uniqueValues(tLive.releases, 'os').forEach(function (v) { tLiveOs[v] = true; });
-    uniqueValues(tLive.releases, 'arch').forEach(function (v) { tLiveArch[v] = true; });
-
-    // Skip packages where LIVE has no classified entries (all empty os/arch).
-    // These are github_releases packages where classification happens at query
-    // time. Our _cache filling in values is an improvement, not a regression.
-    var liveOsKeys = Object.keys(tLiveOs);
-    var liveArchKeys = Object.keys(tLiveArch);
-    if (liveOsKeys.length === 0 && liveArchKeys.length === 0) {
-      tagSkipped++;
-      continue;
-    }
-
-    var tCacheOs = uniqueValues(tCache.releases, 'os');
-    var tCacheArch = uniqueValues(tCache.releases, 'arch');
-
-    var tNewOs = tCacheOs.filter(function (v) { return !tLiveOs[v]; });
-    var tNewArch = tCacheArch.filter(function (v) { return !tLiveArch[v]; });
-
-    if (tNewOs.length > 0 || tNewArch.length > 0) {
-      tagIssues.push({
-        pkg: tpkg,
-        newOs: tNewOs,
-        newArch: tNewArch,
-      });
-    }
-  }
-
-  if (tagSkipped > 0) {
-    console.log('  INFO skipped ' + tagSkipped + ' packages with no LIVE classification (unclassified github_releases)');
-  }
-  if (tagIssues.length === 0) {
-    console.log('  PASS no pre-classified packages introduce new tags');
-    passes++;
-  } else {
-    for (var tii = 0; tii < tagIssues.length; tii++) {
-      var tissue = tagIssues[tii];
-      var parts = [];
-      if (tissue.newOs.length > 0) {
-        parts.push('os: ' + JSON.stringify(tissue.newOs));
-      }
-      if (tissue.newArch.length > 0) {
-        parts.push('arch: ' + JSON.stringify(tissue.newArch));
-      }
-      console.log('  WARN ' + tissue.pkg + ': new tags: ' + parts.join(', '));
-      warns++;
-    }
-  }
-
-  // ================================================================
-  // Test 5: Latest stable version — _cache should be >= LIVE
-  // ================================================================
-  console.log('');
-  console.log('=== Test 5: Latest Stable Version ===');
-  console.log('');
-
-  var stableCheckPkgs = ['bat', 'go', 'node', 'rg', 'caddy', 'jq', 'hugo', 'terraform'];
-  for (var si = 0; si < stableCheckPkgs.length; si++) {
-    var spkg = stableCheckPkgs[si];
-    var sLive = loadReleases(livePath, spkg);
-    var sCache = loadReleases(cachePath, spkg);
-    if (!sLive || !sCache) {
-      console.log('  SKIP ' + spkg + ': missing data');
-      continue;
-    }
-
-    // Find first stable release in each
-    var liveStable = sLive.releases.find(function (r) { return r.channel === 'stable'; });
-    var cacheStable = sCache.releases.find(function (r) { return r.channel === 'stable'; });
-
-    if (!liveStable || !cacheStable) {
-      console.log('  SKIP ' + spkg + ': no stable release found');
-      continue;
-    }
-
-    var lv = (liveStable.version || '').replace(/^v/, '');
-    var cv = (cacheStable.version || '').replace(/^v/, '');
-
-    if (lv === cv) {
-      console.log('  PASS ' + spkg + ': ' + cv);
-      passes++;
-    } else {
-      // Just warn — versions may differ due to cache age
-      console.log('  WARN ' + spkg + ': LIVE=' + lv + ' _cache=' + cv);
-      warns++;
-    }
-  }
-
-  // ================================================================
-  // Test 6: Download URLs — all entries should have valid URLs
-  // ================================================================
-  console.log('');
-  console.log('=== Test 6: Download URL Validity ===');
-  console.log('');
-
-  var urlIssues = [];
-  for (var ui = 0; ui < common.length; ui++) {
-    var upkg = common[ui];
-    var uCache = loadReleases(cachePath, upkg);
-    if (!uCache) { continue; }
-
-    var emptyUrls = 0;
-    var badUrls = 0;
-    for (var uri = 0; uri < uCache.releases.length; uri++) {
-      var rel = uCache.releases[uri];
-      var url = rel.download || '';
-      if (url === '') {
-        emptyUrls++;
-      } else if (!/^https?:\/\//.test(url)) {
-        badUrls++;
-      }
-    }
-    if (emptyUrls > 0 || badUrls > 0) {
-      urlIssues.push({ pkg: upkg, empty: emptyUrls, bad: badUrls });
-    }
-  }
-
-  if (urlIssues.length === 0) {
-    console.log('  PASS all packages have valid download URLs');
-    passes++;
-  } else {
-    for (var uii = 0; uii < urlIssues.length; uii++) {
-      var uissue = urlIssues[uii];
-      var uparts = [];
-      if (uissue.empty > 0) { uparts.push(uissue.empty + ' empty'); }
-      if (uissue.bad > 0) { uparts.push(uissue.bad + ' malformed'); }
-      console.log('  FAIL ' + uissue.pkg + ': ' + uparts.join(', '));
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Test 7: Required fields — all entries should have version + name
-  // ================================================================
-  console.log('');
-  console.log('=== Test 7: Required Fields ===');
-  console.log('');
-
-  var fieldIssues = [];
-  for (var fi = 0; fi < common.length; fi++) {
-    var fpkg = common[fi];
-    var fCache = loadReleases(cachePath, fpkg);
-    if (!fCache) { continue; }
-
-    var noVersion = 0;
-    var noName = 0;
-    for (var fri = 0; fri < fCache.releases.length; fri++) {
-      var frel = fCache.releases[fri];
-      if (!frel.version) { noVersion++; }
-      if (!frel.name && !frel.download) { noName++; }
-    }
-    if (noVersion > 0 || noName > 0) {
-      fieldIssues.push({ pkg: fpkg, noVersion: noVersion, noName: noName });
-    }
-  }
-
-  if (fieldIssues.length === 0) {
-    console.log('  PASS all packages have version and name/download');
-    passes++;
-  } else {
-    for (var fii = 0; fii < fieldIssues.length; fii++) {
-      var fissue = fieldIssues[fii];
-      var fparts = [];
-      if (fissue.noVersion > 0) { fparts.push(fissue.noVersion + ' missing version'); }
-      if (fissue.noName > 0) { fparts.push(fissue.noName + ' missing name+download'); }
-      console.log('  FAIL ' + fissue.pkg + ': ' + fparts.join(', '));
-      failures++;
-    }
-  }
-
-  // ================================================================
-  // Summary
-  // ================================================================
-  console.log('');
-  console.log('=== Results: ' + passes + ' passed, ' + failures + ' failed, ' + warns + ' warnings ===');
-  if (failures > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-live-compare.js

@@ -1,577 +0,0 @@
-'use strict';
-
-// Comprehensive live-vs-local comparison test.
-// Fetches from a remote API (default: webinstall.dev) and compares against
-// local cache-only output to catch regressions.
-//
-// Usage:
-//   node _webi/test-live-compare.js                              # compare against prod
-//   node _webi/test-live-compare.js --refresh                    # refresh golden data
-//   node _webi/test-live-compare.js --base-url=https://beta.webi.sh
-//   node _webi/test-live-compare.js --all                        # all cached pkgs
-//   node _webi/test-live-compare.js --all --tsv                  # TSV output
-//   node _webi/test-live-compare.js --base-url=https://webi.sh \
-//        --cand-url=https://beta.webi.sh                          # remote-vs-remote
-//                                                                 # (Test 4 only;
-//                                                                 #  no local cache
-//                                                                 #  needed)
-
-let Fs = require('node:fs/promises');
-let Os = require('node:os');
-let Path = require('node:path');
-let Https = require('node:https');
-
-let Releases = require('./transform-releases.js');
-let InstallerServer = require('./serve-installer.js');
-let Builds = require('./builds.js');
-
-let TESTDATA_DIR = Path.join(__dirname, 'testdata');
-let CACHE_DIR = Path.join(Os.homedir(), '.cache/webi/legacy');
-
-let REFRESH = process.argv.includes('--refresh');
-let ALL_PKGS = process.argv.includes('--all');
-let TSV = process.argv.includes('--tsv');
-
-let BASE_URL = 'https://webinstall.dev';
-let CAND_URL = '';
-for (let arg of process.argv) {
-  if (arg.startsWith('--base-url=')) {
-    BASE_URL = arg.slice('--base-url='.length).replace(/\/+$/, '');
-  } else if (arg.startsWith('--cand-url=')) {
-    CAND_URL = arg.slice('--cand-url='.length).replace(/\/+$/, '');
-  }
-}
-
-// Packages to test — mix of Go-built, Rust-built, and C/C++ projects
-let TEST_PKGS = ['bat', 'go', 'node', 'rg', 'jq', 'caddy'];
-
-async function listCachedPkgs() {
-  let entries;
-  try {
-    entries = await Fs.readdir(CACHE_DIR);
-  } catch (e) {
-    console.error(`No cache directory: ${CACHE_DIR}`);
-    return [];
-  }
-  let pkgs = entries
-    .filter(function (n) { return n.endsWith('.json'); })
-    .map(function (n) { return n.slice(0, -5); })
-    .sort();
-  return pkgs;
-}
-
-// OS/arch combos for filtered release API tests
-let RELEASE_API_CASES = [
-  { os: 'macos', arch: 'amd64' },
-  { os: 'macos', arch: 'arm64' },
-  { os: 'linux', arch: 'amd64' },
-  { os: 'windows', arch: 'amd64' },
-];
-
-// Older / channel-specific version specs that map to webi <pkg>@<spec>
-// invocations. Each case exercises a code path that the unfiltered
-// "@stable" sweep above would never hit:
-//   - LTS filter (lts=true)
-//   - Channel filter (channel=beta)
-//   - Major-series prefix (ver=20 → /^20\b/)
-//   - Older minor (ver=0.18 → /^0.18\b/)
-//   - Older major (ver=1.21 → /^1.21\b/) for projects with deep history
-let VERSION_SPEC_CASES = [
-  { pkg: 'node', spec: 'lts',  ver: '',     channel: '',     lts: true,  os: 'linux', arch: 'amd64' },
-  { pkg: 'node', spec: '20',   ver: '20',   channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'node', spec: 'beta', ver: '',     channel: 'beta', lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'go',   spec: '1.22', ver: '1.22', channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'go',   spec: '1.21', ver: '1.21', channel: '',     lts: false, os: 'macos', arch: 'arm64' },
-  { pkg: 'bat',  spec: '0.20', ver: '0.20', channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'bat',  spec: '0.18', ver: '0.18', channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'rg',   spec: '13',   ver: '13',   channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-  { pkg: 'caddy', spec: '2.7', ver: '2.7',  channel: '',     lts: false, os: 'linux', arch: 'amd64' },
-];
-
-// UA strings for installer resolution tests
-let INSTALLER_CASES = [
-  { label: 'macOS arm64', ua: 'aarch64/unknown Darwin/24.2.0 libc' },
-  { label: 'macOS amd64', ua: 'x86_64/unknown Darwin/23.0.0 libc' },
-  { label: 'Linux musl', ua: 'x86_64/unknown Linux/5.15.0 musl' },
-  { label: 'Windows amd64', ua: 'x86_64/unknown Windows/10.0.19041 msvc' },
-];
-
-// Known differences between Go cache and production (not regressions)
-// Extensions that the Go cache correctly excludes (non-installable formats)
-// OR that the Go cache includes but shouldn't (man pages, etc.)
-let KNOWN_EXT_DIFFS = new Set([
-  'deb', 'rpm', 'sha256', 'sig', 'pem', 'sbom', 'txt',
-  '1', '2', '3', '4', '5', '6', '7', '8',  // man page extensions
-]);
-
-function httpsGet(url) {
-  return new Promise(function (resolve, reject) {
-    Https.get(url, function (res) {
-      let data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        if (res.statusCode !== 200) {
-          reject(new Error(`HTTP ${res.statusCode}: ${url}`));
-          return;
-        }
-        resolve(data);
-      });
-    }).on('error', reject);
-  });
-}
-
-async function fetchLiveReleases(pkg, os, arch, limit) {
-  let url = `${BASE_URL}/api/releases/${pkg}@stable.json?limit=${limit || 100}`;
-  if (os) {
-    url += `&os=${os}`;
-  }
-  if (arch) {
-    url += `&arch=${arch}`;
-  }
-  let json = await httpsGet(url);
-  return JSON.parse(json);
-}
-
-async function fetchAtSpec(baseUrl, pkg, spec, os, arch) {
-  let url = `${baseUrl}/api/releases/${pkg}@${spec}.json?limit=1`;
-  if (os) {
-    url += `&os=${os}`;
-  }
-  if (arch) {
-    url += `&arch=${arch}`;
-  }
-  let json = await httpsGet(url);
-  return JSON.parse(json);
-}
-
-async function fetchLiveInstaller(pkg, ua) {
-  return new Promise(function (resolve, reject) {
-    let url = `${BASE_URL}/${pkg}@stable.sh`;
-    let opts = {
-      headers: { 'User-Agent': ua },
-    };
-    Https.get(url, opts, function (res) {
-      // Follow redirects
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        let redir = res.headers.location;
-        if (redir.startsWith('/')) {
-          redir = BASE_URL + redir;
-        }
-        Https.get(redir, opts, function (res2) {
-          let data = '';
-          res2.on('data', function (chunk) {
-            data += chunk;
-          });
-          res2.on('end', function () {
-            resolve(data);
-          });
-        }).on('error', reject);
-        return;
-      }
-      let data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        resolve(data);
-      });
-    }).on('error', reject);
-  });
-}
-
-function parseInstallerVars(scriptText) {
-  let vars = {};
-  // Match both `export WEBI_FOO='...'` and `WEBI_FOO='...'`
-  let names = ['WEBI_PKG_URL', 'WEBI_VERSION', 'WEBI_EXT', 'WEBI_OS', 'WEBI_ARCH', 'PKG_NAME'];
-  for (let name of names) {
-    let re = new RegExp("^(?:export\\s+)?" + name + "='([^']*)'", 'm');
-    let m = scriptText.match(re);
-    if (m) {
-      vars[name] = m[1];
-    }
-  }
-  return vars;
-}
-
-async function saveGolden(name, data) {
-  await Fs.mkdir(TESTDATA_DIR, { recursive: true });
-  let file = Path.join(TESTDATA_DIR, name);
-  await Fs.writeFile(file, JSON.stringify(data), 'utf8');
-}
-
-async function loadGolden(name) {
-  let file = Path.join(TESTDATA_DIR, name);
-  try {
-    let json = await Fs.readFile(file, 'utf8');
-    return JSON.parse(json);
-  } catch (e) {
-    if (e.code === 'ENOENT') {
-      return null;
-    }
-    throw e;
-  }
-}
-
-async function main() {
-  let passes = 0;
-  let failures = 0;
-  let skips = 0;
-  let knowns = 0;
-
-  console.log('Initializing build cache...');
-  await Builds.init();
-  console.log('');
-
-  // ================================================================
-  // Test 1: Release API — unfiltered
-  // ================================================================
-  console.log('=== Test 1: Unfiltered /api/releases/{pkg}.json ===');
-  console.log('');
-
-  for (let pkg of TEST_PKGS) {
-    let goldenName = `live_${pkg}.json`;
-    let liveReleases;
-
-    if (REFRESH) {
-      try {
-        liveReleases = await fetchLiveReleases(pkg);
-        await saveGolden(goldenName, liveReleases);
-        console.log(`  refreshed ${goldenName}`);
-      } catch (e) {
-        console.log(`  SKIP ${pkg}: fetch error: ${e.message}`);
-        skips++;
-        continue;
-      }
-    } else {
-      liveReleases = await loadGolden(goldenName);
-      if (!liveReleases) {
-        console.log(`  SKIP ${pkg}: no golden data (run with --refresh)`);
-        skips++;
-        continue;
-      }
-    }
-
-    let localResult = await Releases.getReleases({
-      pkg: pkg,
-      ver: '',
-      os: '',
-      arch: '',
-      libc: '',
-      lts: false,
-      channel: '',
-      formats: [],
-      limit: 100,
-    });
-    let localReleases = localResult.releases;
-
-    // Compare OS vocabulary — check that local has the core OSes that live has
-    let liveOses = [...new Set(liveReleases.map(function (r) { return r.os; }))].sort();
-    let localOses = [...new Set(localReleases.map(function (r) { return r.os; }))].sort();
-    let coreOses = ['linux', 'macos', 'windows'];
-    let liveCore = liveOses.filter(function (o) { return coreOses.includes(o); }).sort();
-    let localCore = localOses.filter(function (o) { return coreOses.includes(o); }).sort();
-    // Local should have at least the core OSes that live has
-    let missingCore = liveCore.filter(function (o) { return !localCore.includes(o); });
-    if (missingCore.length > 0) {
-      console.log(`  FAIL ${pkg} OS: missing core OSes: ${JSON.stringify(missingCore)}`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg} OS: ${JSON.stringify(localCore)}`);
-      passes++;
-    }
-
-    // Compare ext vocabulary (excluding known non-installable formats)
-    let liveExts = [...new Set(liveReleases.map(function (r) { return r.ext; }))].sort();
-    let localExts = [...new Set(localReleases.map(function (r) { return r.ext; }))].sort();
-    let liveExtsFiltered = liveExts.filter(function (e) { return !KNOWN_EXT_DIFFS.has(e); });
-    let localExtsFiltered = localExts.filter(function (e) { return !KNOWN_EXT_DIFFS.has(e); });
-    let extMatch = true;
-    for (let ext of localExtsFiltered) {
-      if (!liveExtsFiltered.includes(ext)) {
-        // Local has a real ext that live doesn't — may be due to limit or sampling
-        // Only fail if it's clearly wrong (not a standard installable format)
-        let installable = ['tar.gz', 'tar.xz', 'tar.bz2', 'zip', 'exe', 'dmg', 'pkg', 'msi', '7z', 'xz'];
-        if (!installable.includes(ext)) {
-          console.log(`  FAIL ${pkg} ext: local has unexpected '${ext}'`);
-          failures++;
-          extMatch = false;
-          break;
-        }
-      }
-    }
-    if (extMatch) {
-      console.log(`  PASS ${pkg} ext: ${JSON.stringify(localExtsFiltered)}`);
-      passes++;
-    }
-
-    // Version format — no 'v' prefix
-    let hasVPrefix = localReleases.some(function (r) {
-      return r.version && r.version.startsWith('v');
-    });
-    if (hasVPrefix) {
-      console.log(`  FAIL ${pkg}: versions have 'v' prefix`);
-      failures++;
-    } else {
-      console.log(`  PASS ${pkg}: no 'v' prefix`);
-      passes++;
-    }
-  }
-
-  // ================================================================
-  // Test 2: Release API — filtered by OS/arch
-  // ================================================================
-  console.log('');
-  console.log('=== Test 2: Filtered /api/releases/{pkg}@stable.json?os=...&arch=... ===');
-  console.log('');
-
-  for (let pkg of TEST_PKGS) {
-    for (let tc of RELEASE_API_CASES) {
-      let goldenName = `live_${pkg}_os_${tc.os}_arch_${tc.arch}.json`;
-      let liveReleases;
-
-      if (REFRESH) {
-        try {
-          liveReleases = await fetchLiveReleases(pkg, tc.os, tc.arch, 1);
-          await saveGolden(goldenName, liveReleases);
-        } catch (e) {
-          skips++;
-          continue;
-        }
-      } else {
-        liveReleases = await loadGolden(goldenName);
-        if (!liveReleases) {
-          skips++;
-          continue;
-        }
-      }
-
-      let liveFirst = liveReleases[0];
-      if (!liveFirst || liveFirst.channel === 'error') {
-        skips++;
-        continue;
-      }
-
-      let localResult = await Releases.getReleases({
-        pkg: pkg,
-        ver: '',
-        os: tc.os,
-        arch: tc.arch,
-        libc: '',
-        lts: false,
-        channel: 'stable',
-        formats: [],
-        limit: 1,
-      });
-      let localFirst = localResult.releases[0];
-
-      if (!localFirst || localFirst.channel === 'error') {
-        console.log(`  FAIL ${pkg} ${tc.os}/${tc.arch}: local returned error/empty`);
-        failures++;
-        continue;
-      }
-
-      let diffs = [];
-      // Compare os, arch, ext (skip version/download since cache age may differ)
-      if (liveFirst.os !== localFirst.os) {
-        diffs.push(`os: live=${liveFirst.os} local=${localFirst.os}`);
-      }
-      if (liveFirst.arch !== localFirst.arch) {
-        diffs.push(`arch: live=${liveFirst.arch} local=${localFirst.arch}`);
-      }
-      if (liveFirst.ext !== localFirst.ext) {
-        if (KNOWN_EXT_DIFFS.has(liveFirst.ext)) {
-          // Live returns a non-installable format (deb, pem, etc.) — known
-          console.log(`  KNOWN ${pkg} ${tc.os}/${tc.arch}: live ext '${liveFirst.ext}' excluded by Go cache, local='${localFirst.ext}'`);
-          knowns++;
-          continue;
-        }
-        diffs.push(`ext: live=${liveFirst.ext} local=${localFirst.ext}`);
-      }
-
-      if (diffs.length > 0) {
-        console.log(`  FAIL ${pkg} ${tc.os}/${tc.arch}: ${diffs.join(', ')}`);
-        failures++;
-      } else {
-        console.log(`  PASS ${pkg} ${tc.os}/${tc.arch}: v${localFirst.version} .${localFirst.ext}`);
-        passes++;
-      }
-    }
-  }
-
-  // ================================================================
-  // Test 3: Installer resolution — compare rendered script vars
-  // ================================================================
-  console.log('');
-  console.log('=== Test 3: Installer script variables (local serveInstaller vs live) ===');
-  console.log('');
-
-  for (let pkg of ['bat', 'go', 'rg']) {
-    for (let tc of INSTALLER_CASES) {
-      // Get local result
-      let localVars;
-      try {
-        let script = await InstallerServer.serveInstaller(
-          'https://webi.sh',
-          tc.ua,
-          pkg,
-          'stable',
-          'sh',
-          ['tar', 'exe', 'zip', 'xz', 'dmg'],
-          '',
-        );
-        localVars = parseInstallerVars(script);
-      } catch (e) {
-        console.log(`  ERROR ${pkg} ${tc.label}: ${e.message}`);
-        failures++;
-        continue;
-      }
-
-      if (!localVars.WEBI_PKG_URL || localVars.WEBI_PKG_URL === '') {
-        // Check if this is a known issue
-        if (localVars.WEBI_EXT === 'err') {
-          console.log(`  KNOWN ${pkg} ${tc.label}: no match (WATERFALL gap)`);
-          knowns++;
-          continue;
-        }
-        console.log(`  FAIL ${pkg} ${tc.label}: empty WEBI_PKG_URL`);
-        failures++;
-        continue;
-      }
-
-      // Verify the URL looks like a real download
-      let url = localVars.WEBI_PKG_URL;
-      let hasRealDomain = url.includes('github.com') ||
-                          url.includes('dl.google.com') ||
-                          url.includes('nodejs.org') ||
-                          url.includes('jqlang');
-      if (!hasRealDomain) {
-        console.log(`  FAIL ${pkg} ${tc.label}: suspicious URL: ${url}`);
-        failures++;
-        continue;
-      }
-
-      // Verify version is set and has no 'v' prefix
-      if (!localVars.WEBI_VERSION || localVars.WEBI_VERSION === '0.0.0') {
-        console.log(`  FAIL ${pkg} ${tc.label}: bad version: ${localVars.WEBI_VERSION}`);
-        failures++;
-        continue;
-      }
-
-      // Verify ext is a real installable format
-      let ext = localVars.WEBI_EXT;
-      let goodExts = ['tar.gz', 'tar.xz', 'zip', 'exe', 'dmg', 'pkg', 'msi', '7z'];
-      if (!goodExts.includes(ext)) {
-        console.log(`  FAIL ${pkg} ${tc.label}: bad ext: ${ext}`);
-        failures++;
-        continue;
-      }
-
-      console.log(`  PASS ${pkg} ${tc.label}: v${localVars.WEBI_VERSION} .${ext} ${url.split('/').pop()}`);
-      passes++;
-    }
-  }
-
-  // ================================================================
-  // Test 4: @version path-form parity (webi <pkg>@<spec>)
-  // Exercises lts/channel/version filters that the unfiltered sweep
-  // doesn't touch. Two modes:
-  //   - --cand-url=<url> set:  remote (BASE_URL) vs remote (CAND_URL).
-  //                            No local cache needed.
-  //   - --cand-url unset:      remote (BASE_URL) vs in-process Releases.
-  // ================================================================
-  console.log('');
-  if (CAND_URL) {
-    console.log(`=== Test 4: @version filter parity (${BASE_URL} vs ${CAND_URL}) ===`);
-  } else {
-    console.log('=== Test 4: @version filter parity (remote vs local resolver) ===');
-  }
-  console.log('');
-
-  for (let tc of VERSION_SPEC_CASES) {
-    let label = `${tc.pkg}@${tc.spec} ${tc.os}/${tc.arch}`;
-
-    let baseFirst;
-    try {
-      let baseRel = await fetchAtSpec(BASE_URL, tc.pkg, tc.spec, tc.os, tc.arch);
-      baseFirst = baseRel[0];
-    } catch (e) {
-      console.log(`  SKIP ${label}: base fetch error: ${e.message}`);
-      skips++;
-      continue;
-    }
-    if (!baseFirst || baseFirst.channel === 'error') {
-      console.log(`  SKIP ${label}: base returned error/empty`);
-      skips++;
-      continue;
-    }
-
-    let candFirst;
-    if (CAND_URL) {
-      try {
-        let candRel = await fetchAtSpec(CAND_URL, tc.pkg, tc.spec, tc.os, tc.arch);
-        candFirst = candRel[0];
-      } catch (e) {
-        console.log(`  FAIL ${label}: cand fetch error: ${e.message}`);
-        failures++;
-        continue;
-      }
-    } else {
-      let localResult = await Releases.getReleases({
-        pkg: tc.pkg,
-        ver: tc.ver,
-        os: tc.os,
-        arch: tc.arch,
-        libc: '',
-        lts: tc.lts,
-        channel: tc.channel,
-        formats: [],
-        limit: 1,
-      });
-      candFirst = localResult.releases && localResult.releases[0];
-    }
-    if (!candFirst || candFirst.channel === 'error') {
-      console.log(`  FAIL ${label}: cand returned error/empty (base=${baseFirst.version})`);
-      failures++;
-      continue;
-    }
-
-    // Both should satisfy the requested spec. A version diff is only a
-    // real failure if cand picked something the spec excludes (e.g.
-    // requested '20' but got '26'). Same prefix on both sides is just
-    // cache-age skew (e.g. 1.21.13 vs 1.21.14).
-    if (baseFirst.version !== candFirst.version) {
-      let prefix = tc.ver;
-      let candMatches = !prefix || new RegExp('^' + prefix + '\\b').test(candFirst.version);
-      let baseMatches = !prefix || new RegExp('^' + prefix + '\\b').test(baseFirst.version);
-      if (!candMatches && baseMatches) {
-        console.log(`  FAIL ${label}: cand=${candFirst.version} doesn't match spec; base=${baseFirst.version}`);
-        failures++;
-      } else if (candMatches && !baseMatches) {
-        console.log(`  PASS ${label}: cand=${candFirst.version} (base=${baseFirst.version} is wrong)`);
-        passes++;
-      } else {
-        console.log(`  PASS ${label}: cand=${candFirst.version} base=${baseFirst.version} (both match '${prefix}'; cache-age skew)`);
-        passes++;
-      }
-    } else {
-      console.log(`  PASS ${label}: v${candFirst.version}`);
-      passes++;
-    }
-  }
-
-  // ================================================================
-  // Summary
-  // ================================================================
-  console.log('');
-  console.log(`=== Results: ${passes} passed, ${failures} failed, ${knowns} known, ${skips} skipped ===`);
-  if (failures > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test-live-installer-diff.js

@@ -1,202 +0,0 @@
-'use strict';
-
-// Direct side-by-side comparison: fetch the live installer script from
-// a remote host with the same UA, and compare WEBI_* variables against
-// what our local serveInstaller() produces.
-//
-// This is the most direct behavioral equivalence test — if the same UA
-// produces the same WEBI_PKG_URL, WEBI_VERSION, WEBI_EXT, and WEBI_OS,
-// then the user gets the same binary.
-//
-// Usage:
-//   node _webi/test-live-installer-diff.js
-//   node _webi/test-live-installer-diff.js --base-url=https://beta.webi.sh
-
-let Https = require('node:https');
-let InstallerServer = require('./serve-installer.js');
-let Builds = require('./builds.js');
-
-let BASE_URL = 'https://webinstall.dev';
-for (let arg of process.argv) {
-  if (arg.startsWith('--base-url=')) {
-    BASE_URL = arg.slice('--base-url='.length).replace(/\/+$/, '');
-  }
-}
-
-let CASES = [
-  // bat — Rust project, gnu-linked Linux builds
-  { pkg: 'bat', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'bat macOS arm64' },
-  { pkg: 'bat', ua: 'x86_64/unknown Darwin/23.0.0 libc', label: 'bat macOS amd64' },
-  { pkg: 'bat', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'bat Linux amd64' },
-  { pkg: 'bat', ua: 'x86_64/unknown Linux/5.15.0 musl', label: 'bat Linux musl' },
-  { pkg: 'bat', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'bat Windows amd64' },
-  // go — Go project, static builds (libc='none')
-  { pkg: 'go', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'go macOS arm64' },
-  { pkg: 'go', ua: 'x86_64/unknown Darwin/23.0.0 libc', label: 'go macOS amd64' },
-  { pkg: 'go', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'go Linux amd64' },
-  { pkg: 'go', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'go Windows amd64' },
-  // node — C++ project, gnu-linked Linux builds, separate musl build
-  { pkg: 'node', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'node macOS arm64' },
-  { pkg: 'node', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'node Linux amd64',
-    known: 'live fails (WATERFALL gap), local correctly resolves gnu build' },
-  { pkg: 'node', ua: 'x86_64/unknown Linux/5.15.0 musl', label: 'node Linux musl' },
-  // rg — Rust project, gnu-linked Linux builds
-  { pkg: 'rg', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'rg macOS arm64' },
-  { pkg: 'rg', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'rg Linux amd64' },
-  { pkg: 'rg', ua: 'x86_64/unknown Linux/5.15.0 musl', label: 'rg Linux musl' },
-  { pkg: 'rg', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'rg Windows amd64' },
-  // jq — C project, had .git source URLs in old releases
-  { pkg: 'jq', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'jq macOS arm64' },
-  { pkg: 'jq', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'jq Linux amd64' },
-  { pkg: 'jq', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'jq Windows amd64' },
-  // caddy — Go project, had .git source URLs in old releases
-  { pkg: 'caddy', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'caddy macOS arm64' },
-  { pkg: 'caddy', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'caddy Linux amd64' },
-  { pkg: 'caddy', ua: 'x86_64/unknown Windows/10.0.19041 msvc', label: 'caddy Windows amd64' },
-  // Additional packages for broader coverage
-  { pkg: 'shellcheck', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'shellcheck macOS arm64' },
-  { pkg: 'shellcheck', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'shellcheck Linux amd64' },
-  { pkg: 'shfmt', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'shfmt macOS arm64' },
-  { pkg: 'shfmt', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'shfmt Linux amd64' },
-  { pkg: 'fd', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'fd macOS arm64' },
-  { pkg: 'fd', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'fd Linux amd64' },
-  { pkg: 'hugo', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'hugo macOS arm64',
-    known: 'classifier rejects darwin-universal as x86_64!=universal2' },
-  { pkg: 'hugo', ua: 'x86_64/unknown Linux/5.15.0 libc', label: 'hugo Linux amd64' },
-  // Alias tests — these should resolve to the real package
-  { pkg: 'golang', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'golang alias macOS arm64' },
-  { pkg: 'ripgrep', ua: 'aarch64/unknown Darwin/24.2.0 libc', label: 'ripgrep alias macOS arm64' },
-];
-
-// Variables that must match between live and local for the install to work
-let CRITICAL_VARS = ['PKG_NAME', 'WEBI_OS', 'WEBI_ARCH', 'WEBI_EXT'];
-// Variables where version differences are OK (cache age)
-let VERSION_VARS = ['WEBI_VERSION', 'WEBI_PKG_URL', 'WEBI_PKG_FILE'];
-
-function fetchLiveInstaller(pkg, ua) {
-  return new Promise(function (resolve, reject) {
-    let url = `${BASE_URL}/api/installers/${pkg}@stable.sh`;
-    let opts = { headers: { 'User-Agent': ua } };
-    Https.get(url, opts, function (res) {
-      let data = '';
-      res.on('data', function (chunk) { data += chunk; });
-      res.on('end', function () { resolve(data); });
-    }).on('error', reject);
-  });
-}
-
-function parseVars(script) {
-  let vars = {};
-  // Match: PKG_NAME='bat' or WEBI_VERSION='1.2.3' (with or without export)
-  let re = /^(?:export\s+)?(WEBI_\w+|PKG_NAME)='([^']*)'/gm;
-  let m;
-  while ((m = re.exec(script)) !== null) {
-    vars[m[1]] = m[2];
-  }
-  return vars;
-}
-
-async function main() {
-  let passes = 0;
-  let failures = 0;
-  let knowns = 0;
-  let errors = 0;
-
-  console.log('Initializing build cache...');
-  await Builds.init();
-  console.log('');
-
-  console.log('=== Live vs Local Installer Diff ===');
-  console.log('');
-
-  for (let tc of CASES) {
-    // Fetch live
-    let liveScript;
-    try {
-      liveScript = await fetchLiveInstaller(tc.pkg, tc.ua);
-    } catch (e) {
-      console.log(`  SKIP ${tc.label}: fetch error: ${e.message}`);
-      continue;
-    }
-    let liveVars = parseVars(liveScript);
-
-    if (!liveVars.WEBI_PKG_URL) {
-      console.log(`  SKIP ${tc.label}: live returned no WEBI_PKG_URL`);
-      continue;
-    }
-
-    // Render local
-    let localScript;
-    try {
-      localScript = await InstallerServer.serveInstaller(
-        BASE_URL,
-        tc.ua,
-        tc.pkg,
-        'stable',
-        'sh',
-        ['tar', 'exe', 'zip', 'xz', 'dmg'],
-        '',
-      );
-    } catch (e) {
-      console.log(`  ERROR ${tc.label}: local error: ${e.message}`);
-      errors++;
-      continue;
-    }
-    let localVars = parseVars(localScript);
-
-    if (tc.known) {
-      let localExt = localVars.WEBI_EXT || 'err';
-      let liveExt = liveVars.WEBI_EXT || '?';
-      if (localExt !== liveExt) {
-        console.log(`  KNOWN ${tc.label}: ${tc.known} (live=${liveExt} local=${localExt})`);
-        knowns++;
-      } else {
-        console.log(`  PASS ${tc.label}: known issue resolved! v${localVars.WEBI_VERSION} .${localExt}`);
-        passes++;
-      }
-      continue;
-    }
-
-    if (!localVars.WEBI_PKG_URL || localVars.WEBI_EXT === 'err') {
-      console.log(`  KNOWN ${tc.label}: local failed to resolve (live=${liveVars.WEBI_EXT})`);
-      knowns++;
-      continue;
-    }
-
-    // Compare critical vars
-    let diffs = [];
-    for (let v of CRITICAL_VARS) {
-      let liveVal = liveVars[v] || '';
-      let localVal = localVars[v] || '';
-      if (liveVal !== localVal) {
-        diffs.push(`${v}: live='${liveVal}' local='${localVal}'`);
-      }
-    }
-
-    // Log version info (informational, not failure)
-    let versionNote = '';
-    if (liveVars.WEBI_VERSION !== localVars.WEBI_VERSION) {
-      versionNote = ` (version: live=${liveVars.WEBI_VERSION} local=${localVars.WEBI_VERSION})`;
-    }
-
-    if (diffs.length > 0) {
-      console.log(`  FAIL ${tc.label}: ${diffs.join(', ')}${versionNote}`);
-      failures++;
-    } else {
-      let file = (localVars.WEBI_PKG_URL || '').split('/').pop();
-      console.log(`  PASS ${tc.label}: v${localVars.WEBI_VERSION} .${localVars.WEBI_EXT} ${file}${versionNote}`);
-      passes++;
-    }
-  }
-
-  console.log('');
-  console.log(`=== Results: ${passes} passed, ${failures} failed, ${knowns} known, ${errors} errors ===`);
-  if (failures > 0 || errors > 0) {
-    process.exit(1);
-  }
-}
-
-main().catch(function (err) {
-  console.error(err.stack);
-  process.exit(1);
-});

_webi/test.js

@@ -5,7 +5,7 @@
 //
 var usage = [
   'Usage: node _webi/test.js --debug <path-to-package>',
-  'Example: node _webi/test.js --debug ./node/',
+  'Example: node _webi/test.js --debug ./node/'
 ].join('\n');
 
 var count = 3;
@@ -32,10 +32,8 @@ if (/\b-?-h(elp)?\b/.test(process.argv.join(' '))) {
 var os = require('os');
 var fs = require('fs');
 var path = require('path');
-var Builds = require('./builds.js');
-var Installers = require('./installers.js');
-var ServeInstaller = require('./serve-installer.js');
-
+var Releases = require('./releases.js');
+var uaDetect = require('./ua-detect.js');
 var pkg = process.argv[2].split('@');
 var pkgdir = pkg[0];
 var pkgtag = pkg[1] || '';
@@ -44,12 +42,11 @@ var nodes = fs.readdirSync(pkgdir);
 nodes.forEach(function (node) {
   nodesMap[node] = true;
 });
-var baseurl = 'https://webinstall.dev';
 
 var maxLen = 0;
 console.info('');
 console.info('Has the necessary files?');
-['README.md', 'install.sh', 'install.ps1']
+['README.md', 'releases.js', 'install.sh', 'install.ps1']
   .map(function (node) {
     maxLen = Math.max(maxLen, node.length);
     return node;
@@ -65,49 +62,31 @@ console.info('Has the necessary files?');
   });
 
 console.info('');
-let projName = pkgdir.split('/').filter(Boolean).pop();
-Builds.getPackage({ name: projName }).then(async function (/*projInfo*/) {
+Releases.get(path.join(process.cwd(), pkgdir)).then(function (all) {
   var pkgname = path.basename(pkgdir.replace(/\/$/, ''));
-  var nodeOs = os.platform();
-  var nodeOsRelease = os.release();
-  var nodeArch = os.arch();
-  var nodeLibc = 'libc';
-  if (process.platform === 'linux') {
-    nodeLibc = 'gnu';
-    let isUnofficial =
-      process.config.variables.node_release_urlbase.includes('unofficial');
-    if (isUnofficial) {
-      nodeLibc = 'musl';
-    }
-  }
-  var formats = ['exe', 'xz', 'tar', 'zip', 'git'];
+  var osrel = os.platform() + '-' + os.release();
+  var arch = os.arch();
+  var formats = ['exe', 'xz', 'tar', 'zip'];
 
-  let [rel, opts] = await ServeInstaller.helper({
-    unameAgent: `${nodeOs}/${nodeOsRelease} ${nodeArch}/unknown ${nodeLibc}`,
-    projectName: pkgname,
-    tag: pkgtag || '',
-    formats: formats,
-    libc: nodeLibc,
-  });
-  Object.assign(
-    {
-      ver: '',
-      lts: null,
-      channel: '',
-      os: '',
-      arch: '',
-      limit: 0,
-    },
-    opts,
-    {
-      baseurl,
-    },
-  );
+  var rel = all.releases.filter(function (rel) {
+    return (
+      formats.filter(function (ext) {
+        return rel.ext.match(ext);
+      })[0] &&
+      'stable' === rel.channel &&
+      rel.os === uaDetect.os(osrel) &&
+      rel.arch === uaDetect.arch(arch) &&
+      (!pkgtag ||
+        rel.tag === pkgtag ||
+        new RegExp('^' + pkgtag).test(rel.version))
+    );
+  })[0];
+  rel.oses = all.oses;
+  rel.arches = all.arches;
+  rel.formats = all.formats;
 
   if (!rel) {
-    console.error(
-      `Error: ❌ no release found for @${pkgtag}?os=${nodeOs}&arch=${nodeArch}&libc=${nodeLibc}&formats=${formats}`,
-    );
+    console.error('Error: ❌ no release found for current os, arch, and tag');
     process.exit(1);
     return;
   }
@@ -118,8 +97,24 @@ Builds.getPackage({ name: projName }).then(async function (/*projInfo*/) {
   console.info('');
 
   return Promise.all([
-    Installers.renderBash(pkgdir, rel, opts).catch(function () {}),
-    Installers.renderPowerShell(pkgdir, rel, opts).catch(function () {}),
+    Releases.renderBash(pkgdir, rel, {
+      baseurl: 'https://webinstall.dev',
+      pkg: pkgname,
+      tag: pkgtag || '',
+      ver: '',
+      os: osrel,
+      arch,
+      formats: formats
+    }).catch(function () {}),
+    Releases.renderPowerShell(pkgdir, rel, {
+      baseurl: 'https://webinstall.dev',
+      pkg: pkgname,
+      tag: pkgtag || '',
+      ver: '',
+      os: osrel,
+      arch,
+      formats: formats
+    }).catch(function () {})
   ]).then(function (scripts) {
     var bashTxt = scripts[0];
     var ps1Txt = scripts[1];
@@ -130,22 +125,18 @@ Builds.getPackage({ name: projName }).then(async function (/*projInfo*/) {
       bashTxt = (bashTxt || 'echo ERROR').replace(/#set -x/g, 'set -x');
       ps1Txt = (ps1Txt || 'echo ERROR').replace(
         /REM REM todo debug/g,
-        'REM todo debug',
+        'REM todo debug'
       );
     }
     console.info('Do the scripts actually work?');
     if (bashFile && bashTxt) {
       fs.writeFileSync(bashFile, bashTxt, 'utf-8');
-      console.info('\tNEEDS MANUAL TEST: sh %s', bashFile);
+      console.info('\tNEEDS MANUAL TEST: bash %s', bashFile);
     }
     if (ps1File && ps1Txt) {
       fs.writeFileSync(ps1File, ps1Txt, 'utf-8');
       console.info('\tNEEDS MANUAL TEST: powershell.exe %s', ps1File);
     }
     console.info('');
-    setTimeout(function () {
-      console.warn(`[warn] dangling event loop handle`);
-      process.exit(0);
-    }, 300).unref();
   });
 });

_webi/transform-releases.js

@@ -1,339 +0,0 @@
-'use strict';
-
-var Releases = module.exports;
-
-var Fs = require('node:fs/promises');
-var Os = require('node:os');
-var path = require('path');
-var cache = {};
-
-var LEGACY_CACHE_DIR = path.join(Os.homedir(), '.cache/webi/legacy');
-
-// Sort releases by ext preference and libc within the same version.
-// The cache is already sorted by version (stable before beta, newest first),
-// so we only re-order within the same version string.
-function createFormatsSorter(formats) {
-  return function sortByExtLibc(a, b) {
-    if (a.version !== b.version) {
-      // Array.sort is stable (V8, ES2019), so returning 0 across
-      // versions preserves the cache's pre-sorted version-desc order.
-      return 0;
-    }
-
-    var aExtPri = formats.indexOf(a.ext.replace(/tar\..*/, 'tar'));
-    var bExtPri = formats.indexOf(b.ext.replace(/tar\..*/, 'tar'));
-    if (aExtPri > bExtPri) {
-      return -1;
-    }
-    if (aExtPri < bExtPri) {
-      return 1;
-    }
-
-    // rank builds that don't depend on any form of libc first
-    if (a.libc === 'none' && b.libc !== 'none') {
-      return -1;
-    }
-    if (a.libc !== 'none' && b.libc === 'none') {
-      return 1;
-    }
-
-    return 0;
-  };
-}
-
-async function getCachedReleases(pkg) {
-  // returns { download: '', releases: [{ version, date, os, arch, lts, channel, download}] }
-
-  if (cache[pkg]) {
-    return cache[pkg];
-  }
-
-  let dataFile = `${LEGACY_CACHE_DIR}/${pkg}.json`;
-
-  let json = await Fs.readFile(dataFile, 'utf8').catch(function (err) {
-    if (err.code === 'ENOENT') {
-      return null;
-    }
-    throw err;
-  });
-
-  if (!json) {
-    let empty = { download: '', releases: [] };
-    cache[pkg] = empty;
-    return empty;
-  }
-
-  let all;
-  try {
-    all = JSON.parse(json);
-  } catch (e) {
-    console.error(`error: ${dataFile}:\n\t${e.message}`);
-    let empty = { download: '', releases: [] };
-    cache[pkg] = empty;
-    return empty;
-  }
-
-  cache[pkg] = all;
-  return all;
-}
-
-async function filterReleases(
-  all,
-  { ver, os, arch, libc, lts, channel, formats, limit },
-) {
-  // When multiple formats are downloadable (i.e. .zip and .pkg)
-  // sort the most compatible format first
-  // (i.e. so that we don't do .pkg on linux except on purpose)
-  var rformats = formats.slice(0).reverse();
-  var sortByExtLibc = createFormatsSorter(rformats);
-  var reVer = new RegExp('^' + ver + '\\b');
-
-  function selectMatches(rel) {
-    /* jshint maxcomplexity: 25 */
-    if (os) {
-      // '*' = any OS (matches anything, including windows).
-      // 'posix' / 'posix_20xx' = any POSIX OS (matches linux, macos,
-      // freebsd, etc., but NOT windows).
-      let isPosix = rel.os === 'posix' || rel.os.startsWith('posix_20');
-      let osMatches =
-        rel.os === '*' ||
-        rel.os === os ||
-        (isPosix && os !== 'windows');
-      if (!osMatches) {
-        return false;
-      }
-    }
-
-    if (arch) {
-      if (rel.arch !== '*') {
-        if (rel.arch !== arch) {
-          return false;
-        }
-      }
-    }
-
-    // libc='libc' is serve-releases.js's default when the caller
-    // didn't pin one — treat it as 'no preference', not a filter.
-    let isMeaningfulLibc = libc && libc !== 'libc' && rel.libc !== 'none';
-    if (isMeaningfulLibc) {
-      let releaseRequiresMusl = rel.libc === 'musl';
-      // goal: handle non-glibc (Alpine / Docker / musl)
-      let osHasMusl = libc === 'musl';
-      if (osHasMusl) {
-        // goal: fail if dependent on libc
-        let releaseRequiresLibc = rel.libc === 'gnu';
-        if (releaseRequiresLibc) {
-          return false;
-        }
-      } else if (releaseRequiresMusl) {
-        // goal: don't use musl++ on glibc (Ubuntu, GNU, etc)
-        return false;
-      }
-    }
-
-    if (lts) {
-      if (!rel.lts) {
-        return false;
-      }
-    }
-
-    if (channel) {
-      if (rel.channel !== channel) {
-        return false;
-      }
-    }
-
-    // to match 'tar.gz' and 'tar.xz' with just 'tar'
-    function hasExt(ext) {
-      return rel.ext.match(ext);
-    }
-    if (formats.length) {
-      if (!formats.some(hasExt)) {
-        return false;
-      }
-    }
-
-    if (ver) {
-      if (!rel.version.match(reVer)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  var sortedRels = all.releases.filter(selectMatches).sort(sortByExtLibc);
-  //console.log(sortedRels.slice(0, 4));
-
-  return sortedRels.slice(0, limit || 1000);
-}
-
-Releases.getReleases = function ({
-  _count,
-  pkg,
-  ver,
-  os,
-  arch,
-  libc,
-  lts,
-  channel,
-  formats,
-  limit,
-}) {
-  if (!_count) {
-    _count = 0;
-  }
-  return getCachedReleases(pkg).then(function (all) {
-    return filterReleases(all, {
-      ver,
-      os,
-      arch,
-      libc,
-      lts,
-      channel,
-      formats,
-      limit,
-    })
-      .catch(function (err) {
-        if ('MODULE_NOT_FOUND' === err.code) {
-          return null;
-        }
-        console.error(
-          'TODO: lib/release.js: check type of error, such as MODULE_NOT_FOUND',
-        );
-        console.error(err);
-      })
-      .then(function (releases) {
-        if (releases.length) {
-          return {
-            oses: all.oses,
-            arches: all.arches,
-            libcs: all.libcs,
-            formats: all.formats,
-            releases: releases,
-          };
-        }
-        if (_count < 1) {
-          // Apple Silicon M1 hacky-do workaround fix
-          if ('macos' === os && 'arm64' === arch) {
-            return Releases.getReleases({
-              pkg,
-              ver,
-              os,
-              arch: 'amd64',
-              libc,
-              lts,
-              channel,
-              formats,
-              limit,
-            });
-          }
-          // Windows ARM hacky-do workaround fix
-          if ('windows' === os && 'arm64' === arch) {
-            return Releases.getReleases({
-              pkg,
-              ver,
-              os,
-              arch: 'amd64',
-              libc,
-              lts,
-              channel,
-              formats,
-              limit,
-            });
-          }
-          // Raspberry Pi 3+ on Ubuntu arm64 (via Bionic?)
-          if ('linux' === os && 'arm64' === arch) {
-            return Releases.getReleases({
-              _count: _count + 1,
-              pkg,
-              ver,
-              os,
-              arch: 'armv7l',
-              libc,
-              lts,
-              channel,
-              formats,
-              limit,
-            });
-          }
-          // armv7 can run armv6
-          if ('linux' === os && 'armv7l' === arch) {
-            return Releases.getReleases({
-              _count: _count + 1,
-              pkg,
-              ver,
-              os,
-              arch: 'armv6l',
-              libc,
-              lts,
-              channel,
-              formats,
-              limit,
-            });
-          }
-        }
-        if (_count < 2) {
-          // Raspberry Pi 3+ on Raspbian arm7 (not Ubuntu arm64)
-          // hail mary
-          if ('linux' === os && 'armv7l' === arch) {
-            return Releases.getReleases({
-              _count: _count + 1,
-              pkg,
-              ver,
-              os,
-              arch: 'arm64',
-              libc,
-              lts,
-              channel,
-              formats,
-              limit,
-            });
-          }
-        }
-        releases = [
-          {
-            name: 'doesntexist.ext',
-            version: '0.0.0',
-            lts: '-',
-            channel: 'error',
-            date: '1970-01-01',
-            os: os || '-',
-            arch: arch || '-',
-            libc: libc || '-',
-            ext: 'err',
-            download: 'https://example.com/doesntexist.ext',
-            comment:
-              'No matches found. Could be bad or missing version info' +
-              ',' +
-              "Check query parameters. Should be something like '/api/releases/{package}@{version}.tab?os={macos|linux|windows|-}&arch={amd64|x86|aarch64|arm64|armv7l|-}&libc={musl|gnu|msvc|libc|static}&limit=10'",
-          },
-        ];
-        return {
-          oses: all.oses,
-          arches: all.arches,
-          libcs: all.libcs,
-          formats: all.formats,
-          releases: releases,
-        };
-      });
-  });
-};
-
-if (require.main === module) {
-  return Releases
-    .getReleases({
-      pkg: 'node',
-      ver: '',
-      os: 'macos',
-      arch: 'amd64',
-      lts: true,
-      libc: 'libc',
-      channel: 'stable',
-      formats: ['tar', 'exe', 'zip', 'xz', 'dmg', 'pkg'],
-      limit: 10,
-    })
-    .then(function (all) {
-      console.info(JSON.stringify(all));
-    });
-}

_webi/ua-detect.js

@@ -1,7 +1,5 @@
 'use strict';
 
-var uaDetect = module.exports;
-
 function getRequest(req) {
   var ua = req.headers['user-agent'] || '';
   var os = req.query.os;
@@ -16,11 +14,11 @@ function getRequest(req) {
   }
 
   return {
-    unix: 'curl -fsSA "$(uname -srm)" ' + url,
+    unix: 'curl -fsSA "$(uname -a)" ' + url,
     windows: 'curl.exe -fsSA "MS $Env:PROCESSOR_ARCHITECTURE" ' + url,
     ua: ua,
     os: uaDetect.os(ua),
-    arch: uaDetect.arch(ua),
+    arch: uaDetect.arch(ua)
   };
 }
 
@@ -38,8 +36,9 @@ function getOs(ua) {
     // It's the year of the Linux Desktop!
     // See also http://www.mslinux.org/
     // 'linux' must be tested before 'Microsoft' because WSL
+    // (TODO: does this affect cygwin / msysgit?)
     return 'linux';
-  } else if (/^ms$|Microsoft|Windows|win32|win|PowerShell|CYGWIN|MINGW/i.test(ua)) {
+  } else if (/^ms$|Microsoft|Windows|win32|win|PowerShell/i.test(ua)) {
     // 'win' must be tested after 'darwin'
     return 'windows';
   } else if (/Linux|curl|wget/i.test(ua)) {
@@ -55,23 +54,16 @@ function getArch(ua) {
     return '-';
   }
 
-  // Quick hack for Apple Silicon M1
-  //
-  // Note: we now use `uname -srm` which does not have the native arch
-  // info included with `uname -v` and `uname -a`.
-  //
+  // quick hack for Apple Silicon M1
   // Native:  Darwin boomer.local 20.2.0 Darwin Kernel Version 20.2.0: Wed Dec  2 20:40:21 PST 2020; root:xnu-7195.60.75~1/RELEASE_ARM64_T8101 arm64
   // Resetta: Darwin boomer.local 20.2.0 Darwin Kernel Version 20.2.0: Wed Dec  2 20:40:21 PST 2020; root:xnu-7195.60.75~1/RELEASE_ARM64_T8101 x86_64
-  ua = ua.replace(/xnu-.*RELEASE_[^\s]*/, '');
-
+  ua = ua.replace(/xnu-.*RELEASE_[^\s]*/, '')
   if (/aarch64|arm64|arm8|armv8/i.test(ua)) {
     return 'arm64';
-  } else if (/aarch|arm7|armv7|arm32/i.test(ua)) {
+  } else if (/aarch|arm7|armv7/i.test(ua)) {
     return 'armv7l';
-  } else if (/arm6|armv6|arm(\b|_)/i.test(ua)) {
+  } else if (/arm6|armv6/i.test(ua)) {
     return 'armv6l';
-  } else if (/ppc64le/i.test(ua)) {
-    return 'ppc64le';
   } else if (/ppc64/i.test(ua)) {
     return 'ppc64';
   } else if (/mips64/i.test(ua)) {
@@ -90,63 +82,7 @@ function getArch(ua) {
   }
 }
 
-function getLibc(ua) {
-  if ('-' === ua) {
-    return '-';
-  }
-
-  // How to see a bunch of target host quadruples:
-  //     go tool dist list
-  //     rustup target list
-  //     zig targets | jq -r '.libc[]' | sort -
-
-  // Generally, we prefer 'musl' builds because they DO work on glibc systems (Ubuntu),
-  // but 'glibc' builds will NOT work on musl systems (Alpine / Docker).
-  //
-  // However, there are a few instances (ex: Node.js), where the 'musl' builds
-  // DO NOT work on glibc systems.
-
-  {
-    let muslRe = /(\b|_)(musl)(\b|_)/i;
-    if (muslRe.test(ua)) {
-      return 'musl';
-    }
-  }
-
-  {
-    let msvcRe = /(\b|_)(msvc|windows|microsoft)(\b|_)/i;
-    if (msvcRe.test(ua)) {
-      return 'msvc';
-    }
-  }
-
-  {
-    let gnuRe = /(\b|_)(gnu|glibc|linux)(\b|_)/i;
-    if (gnuRe.test(ua)) {
-      return 'gnu';
-    }
-  }
-
-  {
-    let libcRe = /(\b|_)(libc)(\b|_)/i;
-    if (libcRe.test(ua)) {
-      return 'libc';
-    }
-  }
-
-  {
-    let darwinRe = /(\b|_)(darwin)(\b|_)/i;
-    if (darwinRe.test(ua)) {
-      // not sure whether this should be "darwin" or "libc" or "none"
-      // https://opensource.apple.com/source/Libc/
-      return 'libc';
-    }
-  }
-
-  return 'libc';
-}
-
+var uaDetect = module.exports;
 uaDetect.os = getOs;
 uaDetect.arch = getArch;
-uaDetect.libc = getLibc;
 uaDetect.request = getRequest;

_webi/webi-pwsh.ps1

@@ -0,0 +1,78 @@
+#!/usr/bin/env pwsh
+
+# this allows us to call ps1 files, which allows us to have spaces in filenames
+# ('powershell "$Env:USERPROFILE\test.ps1" foo' will fail if it has a space in
+# the path but '& "$Env:USERPROFILE\test.ps1" foo' will work even with a space)
+Set-ExecutionPolicy -Scope Process Bypass
+
+# If a command returns an error, halt the script.
+$ErrorActionPreference = 'Stop'
+
+# Ignore progress events from cmdlets so Invoke-WebRequest is not painfully slow
+$ProgressPreference = 'SilentlyContinue'
+
+# 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 "") {
+  # This is the canonical CPU arch when the process is native
+  $my_arch = "$Env:PROCESSOR_ARCHITECTURE"
+}
+# TODO API should know to prefer x86 for windows when arm binary is not available
+$Env:WEBI_UA = "Windows/10 $my_arch"
+$exename = $args[0]
+
+# Switch to userprofile
+pushd $Env:USERPROFILE
+
+# Make paths if needed
+New-Item -Path .local\bin -ItemType Directory -Force | out-null
+# TODO replace all xbin with opt\bin\
+New-Item -Path .local\xbin -ItemType Directory -Force | out-null
+
+# See note on Set-ExecutionPolicy above
+Set-Content -Path .local\bin\webi.bat -Value "@echo off`r`npushd %USERPROFILE%`r`npowershell -ExecutionPolicy Bypass .local\bin\webi-pwsh.ps1 %1`r`npopd"
+# Backwards-compat bugfix: remove old webi-pwsh.ps1 location
+Remove-Item -Path .local\bin\webi.ps1 -Recurse -ErrorAction Ignore
+if (!(Test-Path -Path .local\opt))
+{
+    New-Item -Path .local\opt -ItemType Directory -Force | out-null
+}
+# TODO windows version of mktemp -d
+if (!(Test-Path -Path .local\tmp))
+{
+    New-Item -Path .local\tmp -ItemType Directory -Force | out-null
+}
+
+# TODO SetStrictMode
+# TODO Test-Path variable:global:Env:WEBI_HOST ???
+IF($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "")
+{
+    $Env:WEBI_HOST = "https://webinstall.dev"
+}
+
+if (!(Test-Path -Path .local\bin\pathman.exe))
+{
+    & curl.exe -fsSL -A "$Env:WEBI_UA" "$Env:WEBI_HOST/packages/pathman/install.ps1" -o .\.local\tmp\pathman-setup.ps1
+    powershell .\.local\tmp\pathman-setup.ps1
+    # TODO del .\.local\tmp\pathman-setup.bat
+}
+
+# Run pathman to set up the folder
+# (using unix style path because... cmd vs powershell vs whatever)
+& "$Env:USERPROFILE\.local\bin\pathman.exe" add ~/.local/bin
+
+# {{ baseurl }}
+# {{ version }}
+
+# Fetch <whatever>.ps1
+# TODO detect formats
+$PKG_URL = "$Env:WEBI_HOST/api/installers/$exename.ps1?formats=zip,exe,tar"
+echo "Downloading $PKG_URL"
+# Invoke-WebRequest -UserAgent "Windows amd64" "$PKG_URL" -OutFile ".\.local\tmp\$exename.install.ps1"
+& curl.exe -fsSL -A "$Env:WEBI_UA" "$PKG_URL" -o .\.local\tmp\$exename.install.ps1
+
+# Run <whatever>.ps1
+powershell .\.local\tmp\$exename.install.ps1
+
+# Done
+popd

_webi/webi.bat

@@ -0,0 +1,38 @@
+@echo off
+pushd "%userprofile%" || goto :error
+  IF NOT EXIST .local (
+    mkdir .local || goto :error
+  )
+  IF NOT EXIST .local\bin (
+    mkdir .local\bin || goto :error
+  )
+  IF NOT EXIST .local\opt (
+    mkdir .local\opt || goto :error
+  )
+
+  pushd .local\bin || goto :error
+    if NOT EXIST pathman.exe (
+      echo updating PATH management
+      powershell $ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest https://webinstall.dev/packages/pathman/install.bat -OutFile pathman-setup.bat || goto :error
+      call .\pathman-setup.bat || goto :error
+      del pathman-setup.bat  || goto :error
+      rem TODO there's rumor of a windows tool called 'pathman' that does the same thing?
+    )
+  popd || goto :error
+  .\.local\bin\pathman add ".local\bin" || goto :error
+
+  echo downloading and installing %1
+  powershell $ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest https://webinstall.dev/packages/%1/install.ps1 -OutFile %1-webinstall.bat || goto :error
+
+  rem TODO only add if it's not in there already
+  PATH .local\bin;%PATH%
+
+  call %1-webinstall.bat || goto :error
+  del %1-webinstall.bat || goto :error
+popd
+
+goto :EOF
+
+:error
+echo Failed with error #%errorlevel%.
+exit /b %errorlevel%

_webi/webi.ps1.bat

@@ -0,0 +1 @@
+powershell -ExecutionPolicy Bypass .\.local\bin\webi-pwsh.ps1 %1

aliasman/README.md

@@ -1,125 +0,0 @@
----
-title: aliasman
-homepage: https://github.com/BeyondCodeBootcamp/aliasman
-tagline: |
-  aliasman: A cross-shell (POSIX-compliant) alias manager for bash, zsh, and fish
----
-
-To update or switch versions, run `webi aliasman@stable` (or `@v1.0.0`, `@beta`,
-etc).
-
-### Files
-
-These are the files / directories that are created and/or modified with this
-install:
-
-```text
-~/.config/envman/PATH.env
-~/.config/envman/alias.env
-~/.local/bin/aliasman
-```
-
-## Cheat Sheet
-
-> `aliasman` helps you love your *alias*es again! 🥸 \
-> Set 'em once, use 'em everywhere! \
-> (and all in just one dotfile, for an on-the-go friendly config)
-
-```sh
-aliasman <alias-name> <command-name> [args, pipes, redirs, etc]
-```
-
-### What are Aliases?
-
-An _alias_ is just shorthand for a shell function.
-
-Take a long command like this:
-
-```sh
-git commit -m "feat: new feature"
-```
-
-And turn it into a short command, like this:
-
-```sh
-gc "feat: new feature"
-```
-
-(that would be `aliasman gc 'git commit -m'`)
-
-### Imagine the possibilities!
-
-1. What if you could quickly create a _command_, `ll`, \
-   that does the work of `ls -lAhF`!?
-2. Set an _alias_ to do just that!
-   ```sh
-   aliasman ll 'ls -lAhF'
-   ```
-3. Reload your alias config (or open a _new terminal_)
-   ```sh
-   source ~/.config/envman/alias.env
-   ```
-4. Use it!
-   ```sh
-   ll
-   ```
-   ```text
-   drwxr-xr-x aj wheel 416 B  Thu Feb  9 02:08:39 2023 📂 .git/
-   .rwxr-xr-x aj staff 6.2 KB Thu Feb  9 01:36:30 2023 💻 aliasman*
-   .rw-r--r-- aj wheel  16 KB Wed Feb  8 21:51:06 2023 🔑 LICENSE
-   .rw-r--r-- aj wheel 1.4 KB Thu Feb  9 01:47:13 2023 📄 README.md
-   ```
-
-### Common aliases
-
-Use *alias*es to make other tools you find around webi even _more_ convenient ⚡️
-(and powerful 💪).
-
-```sh
-aliasman curl 'curlie'
-
-aliasman diffy 'diff -y --suppress-common-lines'
-
-aliasman gc 'git commit -m'
-aliasman gri 'git rebase -i'
-
-aliasman la 'lsd -AF'
-aliasman ll 'lsd -lAhF'
-aliasman ls 'lsd -F'
-
-aliasman rgi 'rg -i'
-
-aliasman tree 'lsd -F --tree --group-dirs=last'
-
-# random password generator
-aliasman rnd 'xxd -l24 -ps /dev/urandom'
-```
-
-### How to replace an alias
-
-Just run the command again!
-
-```sh
-aliasman ll 'lsd -l'
-aliasman ll 'lsd -lAhF'
-```
-
-### How to delete an alias
-
-With `--delete`!
-
-```sh
-aliasman --delete ll
-```
-
-### How to see an alias
-
-Just supply the name!
-
-```sh
-aliasman rnd
-```
-
-```text
-alias rnd='xxd -l24 -ps /dev/urandom'
-```

aliasman/install.sh

@@ -1,41 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-__init_aliasman() {
-
-    ######################
-    # Install aliasman #
-    ######################
-
-    # Every package should define these 6 variables
-    pkg_cmd_name="aliasman"
-
-    pkg_dst_cmd="$HOME/.local/bin/aliasman"
-    pkg_dst="$pkg_dst_cmd"
-
-    pkg_src_cmd="$HOME/.local/opt/aliasman-v$WEBI_VERSION/bin/aliasman"
-    pkg_src_dir="$HOME/.local/opt/aliasman-v$WEBI_VERSION"
-    pkg_src="$pkg_src_cmd"
-
-    # pkg_install must be defined by every package
-    pkg_install() {
-        # ~/.local/opt/aliasman-v1.0.0/bin
-        mkdir -p "$(dirname "$pkg_src_cmd")"
-
-        # mv ./*aliasman*/aliasman ~/.local/opt/aliasman-v1.0.0/bin/aliasman
-        mv ./*aliasman*/aliasman "$pkg_src_cmd"
-    }
-
-    # pkg_get_current_version is recommended, but (soon) not required
-    pkg_get_current_version() {
-        # 'aliasman version' has output in this format:
-        #       aliasman v1.0.0 (2023-01-15)
-        #       Copyright 2023 AJ ONeal
-        # This trims it down to just the version number:
-        #       1.0.0
-        aliasman version | head -n 1 | cut -d ' ' -f 2 | sed 's:^v::'
-    }
-}
-
-__init_aliasman

aliasman/releases.conf

@@ -1,2 +0,0 @@
-github_sources = BeyondCodeBootcamp/aliasman
-git_url = https://github.com/BeyondCodeBootcamp/aliasman.git

arc/README.md

@@ -5,17 +5,11 @@ tagline: |
   Arc is a cross-platform, multi-format archive utility.
 ---
 
-To update or switch versions, run `webi arc@stable` (or `@v3.5`, `@beta`, etc).
+## Updating `arc`
 
-### Files
+`webi arc@stable`
 
-These are the files / directories that are created and/or modified with this
-install:
-
-```text
-~/.config/envman/PATH.env
-~/.local/bin/arc
-```
+Use the `@beta` tag for pre-releases.
 
 ## Cheat Sheet
 
@@ -28,42 +22,42 @@ create a top-level directory if one does not exist.
 
 ### List
 
-```text
+```txt
 # arc ls <archive file>
 arc ls   example.zip
 ```
 
 ### Unarchive (whole)
 
-```text
+```txt
 # arc unarchive <archive file>
 arc unarchive   example.zip
 ```
 
 ### Extract (partial)
 
-```text
+```txt
 # arc extract <archive file> <archived path> <extracted path>
 arc extract   example.zip    example/foo     ~/Downloads/foo
 ```
 
 ### Archive (recursive)
 
-```text
+```txt
 # arc archive <archive file> <files or folders ...>
 arc archive   example.zip    ./README.md ./bin ./src
 ```
 
 ### Compress (single file)
 
-```text
+```txt
 # arc compress <single file> <format>
 arc compress   ./example.tar xz
 ```
 
 ### Decompress (single file)
 
-```text
+```txt
 # arc decompress <archive file>
 arc decompress   ./example.tar.xz
 ```

arc/install.ps1

@@ -15,39 +15,41 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\archiver-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\archiver-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"
+$pkg_download = "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
-    Write-Output "Downloading archiver from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE"))
+{
+    # TODO: arch detection
+    echo "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"
+    & move "$pkg_download.part" "$pkg_download"
 }
 
-if (!(Test-Path -Path "$pkg_src_cmd")) {
-    Write-Output "Installing archiver"
+IF (!(Test-Path -Path "$pkg_src_cmd"))
+{
+    echo "Installing archiver"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    Push-Location .local\tmp
+    pushd .local\tmp
 
-    # Remove any leftover tmp cruft
-    Remove-Item -Path ".\arc-*" -Recurse -ErrorAction Ignore
-    Remove-Item -Path ".\arc.exe" -Recurse -ErrorAction Ignore
+    	# Remove any leftover tmp cruft
+        Remove-Item -Path ".\arc-*" -Recurse -ErrorAction Ignore
+        Remove-Item -Path ".\arc.exe" -Recurse -ErrorAction Ignore
 
-    # Move single binary into root of temporary folder
-    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "arc.exe"
+        # Move single binary into root of temporary folder
+        & move "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE" "arc.exe"
 
-    # 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 "arc.exe" -Destination "$pkg_src_bin"
+        # Settle unpacked archive into place
+        echo "Install Location: $pkg_src_cmd"
+        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+        Move-Item -Path "arc.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    Pop-Location
+    popd
 }
 
-Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
+echo "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

arc/install.sh

@@ -1,8 +1,6 @@
-#!/bin/sh
-set -e
-set -u
-
-__init_arc() {
+{
+    set -e
+    set -u
 
     ####################
     # Install archiver #
@@ -21,7 +19,7 @@ __init_arc() {
     # pkg_install must be defined by every package
     pkg_install() {
         # ~/.local/opt/arc-v3.2.0/bin
-        mkdir -p "$(dirname "$pkg_src_cmd")"
+        mkdir -p "$(dirname $pkg_src_cmd)"
 
         # mv ./arc_* ~/.local/opt/arc-v3.2.0/bin/arc
         mv ./arc_* "$pkg_src_cmd"
@@ -33,8 +31,6 @@ __init_arc() {
         #       arc v3.5.0 (25e050d) 2020-10-30T03:27:58Z
         # This trims it down to just the version number:
         #       3.5.0
-        arc version 2> /dev/null | head -n 1 | cut -d' ' -f2 | sed 's:^v::'
+        echo "$(arc version 2> /dev/null | head -n 1 | cut -d' ' -f2 | sed 's:^v::')"
     }
 }
-
-__init_arc

arc/releases.conf

@@ -1 +0,0 @@
-github_releases = mholt/archiver

arc/releases.js

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

archiver/README.md

@@ -1,11 +0,0 @@
----
-title: Archiver (arc alias)
-homepage: https://webinstall.dev/arc
-tagline: |
-  Alias for https://webinstall.dev/arc
-alias: arc
-description: |
-  See https://webinstall.dev/arc
----
-
-Alias for https://webinstall.dev/arc

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" }
-curl.exe -A MS -fsSL "$Env:WEBI_HOST/arc@$Env:WEBI_VERSION" | powershell
+echo "'archiver@$Env:WEBI_TAG' is an alias for 'arc@$Env:WEBI_VERSION'"
+IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+curl.exe -fsSL "$Env:WEBI_HOST/arc@$Env:WEBI_VERSION" | powershell

archiver/install.sh

@@ -1,11 +1,10 @@
-#!/bin/sh
-set -e
-set -u
+# title: Archiver (arc alias)
+# homepage: https://webinstall.dev/arc
+# tagline: Alias for https://webinstall.dev/arc
+# alias: arc
+# description: |
+#   See https://webinstall.dev/arc
 
-__redirect_alias_arc() {
-    echo "'archiver@${WEBI_TAG:-stable}' is an alias for 'arc@${WEBI_VERSION-}'"
-    WEBI_HOST=${WEBI_HOST:-"https://webinstall.dev"}
-    curl -fsSL "$WEBI_HOST/arc@${WEBI_VERSION-}" | sh
-}
-
-__redirect_alias_arc
+echo "'archiver@${WEBI_TAG:-stable}' is an alias for 'arc@${WEBI_VERSION:-}'"
+WEBI_HOST=${WEBI_HOST:-"https://webinstall.dev"}
+curl -fsSL "$WEBI_HOST/arc@${WEBI_VERSION:-}" | bash

atomicparsley/README.md

@@ -1,538 +0,0 @@
----
-title: atomicparsley
-homepage: https://github.com/wez/atomicparsley
-tagline: |
-  AtomicParsley is a lightweight tool for reading, parsing and setting iTunes-style metadata.
----
-
-To update or switch versions, run `webi atomicparsley@stable` (or `@v20221229`,
-`@beta`, etc).
-
-### Files
-
-These are the files / directories that are created and/or modified with this
-install:
-
-```text
-~/.config/envman/PATH.env
-~/.local/bin/AtomicParsley
-```
-
-**Windows Users**
-
-```text
-\Windows\System32\vcruntime140.dll
-```
-
-This will also attempt to install the
-[Microsoft Visual C++ Redistributable](/vcruntime) via `webi vcruntime`. If it
-fails and you get the error _`vcruntime140.dll` was not found_, you'll need to
-[install it manually](https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170).
-
-## Cheat Sheet
-
-> `AtomicParsley` is an alternative to `ffmpeg` and `ffprobe` for viewing and
-> changing metadata in MPEG-4 files with .3gp, .3g2, .mp4, .m4a, .m4b, .m4p,
-> .m4r, and .m4v extensions. Because it's purpose-built for MP4 containers, it
-> can do some things `ffmpeg` can't.
-
-### How to Change Album Art
-
-1. Save any existing cover art
-   ```sh
-   AtomicParsley ./my-song.m4a --extractPixToPath ./ 'my-song'
-   ```
-2. Remove the artwork
-   ```sh
-   AtomicParsley ./my-song.m4a --artwork REMOVE_ALL
-   ```
-3. **(macOS ONLY)** Add new artwork at the specified DPI (and other constraints)
-
-   ```sh
-   export PIC_OPTIONS="DPI=72"
-
-   AtomicParsley ./my-podcast-audiobook.m4b --artwork ./my-season-1-cover.jpg
-   ```
-
-Only JPEG and PNG are supported. See `PIC_OPTIONS` down below for more options.
-If you get an error, try exporting your file with a DPI to 72 (or up to 300 with
-`PIC_OPTIONS` set) and a smaller resolution - perhaps 600x600 or 1500x1500 (what
-old versions iTunes versions used).
-
-### How to Remove Apple Account Info
-
-```sh
-AtomicParsley ./my-file.m4a \
-    --DeepScan \
-    --manualAtomRemove "moov.trak.mdia.minf.stbl.mp4a.pinf" \
-    --manualAtomRemove "moov.udta.meta.ilst.apID" \
-    --manualAtomRemove "moov.udta.meta.ilst.cnID" \
-    --manualAtomRemove "moov.udta.meta.ilst.purd" \
-    --manualAtomRemove "moov.udta.meta.ilst.sfID" \
-    --manualAtomRemove "moov.udta.meta.ilst.soal" \
-    --manualAtomRemove "moov.udta.meta.ilst.xid"
-```
-
-If you wanted to also remove information that indicates which Country or
-Language the song was purchased in, or which album it was purchased from, there
-are some additional IDs to consider:
-
-| Metadata Tag                             | Description                                  |
-| ---------------------------------------- | -------------------------------------------- |
-| moov.udta.meta.ilst.apID                 | Apple account email address                  |
-| moov.udta.meta.ilst.ownr                 | Apple account username                       |
-| moov.udta.meta.ilst.atID                 | Artist-track ID                              |
-| moov.udta.meta.ilst.cnID                 | iTunes Catalog ID                            |
-| moov.udta.meta.ilst.geID                 | Genre ID                                     |
-| moov.udta.meta.ilst.plID                 | Playlist ID (identifies album)               |
-| moov.udta.meta.ilst.sfID                 | iTunes store identifier (location/number)    |
-| moov.udta.meta.ilst.cprt                 | Copyright information                        |
-| moov.udta.meta.ilst.flvr                 | Bitrate/video size related                   |
-| moov.udta.meta.ilst.purd                 | Date purchased                               |
-| moov.udta.meta.ilst.rtng                 | Explicit/Clean information                   |
-| moov.udta.meta.ilst.soal                 | Album sort name                              |
-| moov.udta.meta.ilst.stik                 | Media type information                       |
-| moov.udta.meta.ilst.xid                  | Vendor xID                                   |
-| moov.udta.meta.ilst.----.name:[iTunMOVI] | Embedded plist contains filesize and flavor. |
-| moov.trak.mdia.minf.stbl.stsd.mp4a.pinf  | Purchase information related                 |
-
-See <https://gist.github.com/riophae/f5694fd2952cb64982689b971ca6ec79>.
-
-### Genre Lists
-
-All values are **case sensitive**.
-
-#### The "stik" List
-
-These values are **case sensitive**:
-
-0. `Home Video`
-1. `Normal` (meaning music)
-2. `Audiobook` (changes extension to .m4b)
-3. `Whacked Bookmark`
-4. `Music Video`
-5. `Movie`
-6. `Short Film`
-7. `TV Show`
-8. `Booklet`
-
-#### Standard Music Genres
-
-```txt
-(1.)  Blues
-(2.)  Classic Rock
-(3.)  Country
-(4.)  Dance
-(5.)  Disco
-(6.)  Funk
-(7.)  Grunge
-(8.)  Hip-Hop
-(9.)  Jazz
-(10.)  Metal
-(11.)  New Age
-(12.)  Oldies
-(13.)  Other
-(14.)  Pop
-(15.)  R&B
-(16.)  Rap
-(17.)  Reggae
-(18.)  Rock
-(19.)  Techno
-(20.)  Industrial
-(21.)  Alternative
-(22.)  Ska
-(23.)  Death Metal
-(24.)  Pranks
-(25.)  Soundtrack
-(26.)  Euro-Techno
-(27.)  Ambient
-(28.)  Trip-Hop
-(29.)  Vocal
-(30.)  Jazz+Funk
-(31.)  Fusion
-(32.)  Trance
-(33.)  Classical
-(34.)  Instrumental
-(35.)  Acid
-(36.)  House
-(37.)  Game
-(38.)  Sound Clip
-(39.)  Gospel
-(40.)  Noise
-(41.)  AlternRock
-(42.)  Bass
-(43.)  Soul
-(44.)  Punk
-(45.)  Space
-(46.)  Meditative
-(47.)  Instrumental Pop
-(48.)  Instrumental Rock
-(49.)  Ethnic
-(50.)  Gothic
-(51.)  Darkwave
-(52.)  Techno-Industrial
-(53.)  Electronic
-(54.)  Pop-Folk
-(55.)  Eurodance
-(56.)  Dream
-(57.)  Southern Rock
-(58.)  Comedy
-(59.)  Cult
-(60.)  Gangsta
-(61.)  Top 40
-(62.)  Christian Rap
-(63.)  Pop/Funk
-(64.)  Jungle
-(65.)  Native American
-(66.)  Cabaret
-(67.)  New Wave
-(68.)  Psychadelic
-(69.)  Rave
-(70.)  Showtunes
-(71.)  Trailer
-(72.)  Lo-Fi
-(73.)  Tribal
-(74.)  Acid Punk
-(75.)  Acid Jazz
-(76.)  Polka
-(77.)  Retro
-(78.)  Musical
-(79.)  Rock & Roll
-(80.)  Hard Rock
-(81.)  Folk
-(82.)  Folk/Rock
-(83.)  National Folk
-(84.)  Swing
-(85.)  Fast Fusion
-(86.)  Bebob
-(87.)  Latin
-(88.)  Revival
-(89.)  Celtic
-(90.)  Bluegrass
-(91.)  Avantgarde
-(92.)  Gothic Rock
-(93.)  Progressive Rock
-(94.)  Psychedelic Rock
-(95.)  Symphonic Rock
-(96.)  Slow Rock
-(97.)  Big Band
-(98.)  Chorus
-(99.)  Easy Listening
-(100.)  Acoustic
-(101.)  Humour
-(102.)  Speech
-(103.)  Chanson
-(104.)  Opera
-(105.)  Chamber Music
-(106.)  Sonata
-(107.)  Symphony
-(108.)  Booty Bass
-(109.)  Primus
-(110.)  Porn Groove
-(111.)  Satire
-(112.)  Slow Jam
-(113.)  Club
-(114.)  Tango
-(115.)  Samba
-(116.)  Folklore
-(117.)  Ballad
-(118.)  Power Ballad
-(119.)  Rhythmic Soul
-(120.)  Freestyle
-(121.)  Duet
-(122.)  Punk Rock
-(123.)  Drum Solo
-(124.)  A Capella
-(125.)  Euro-House
-(126.)  Dance Hall
-```
-
-#### iTunes Movie Genre IDs
-
-```sh
-AtomicParsley --genre-movie-id-list
-```
-
-```text
-(4401) Action & Adventure
-(4402) Anime
-(4403) Classics
-(4404) Comedy
-(4405) Documentary
-(4406) Drama
-(4407) Foreign
-(4408) Horror
-(4409) Independent
-(4410) Kids & Family
-(4411) Musicals
-(4412) Romance
-(4413) Sci-Fi & Fantasy
-(4414) Short Films
-(4415) Special Interest
-(4416) Thriller
-(4417) Sports
-(4418) Western
-(4419) Urban
-(4420) Holiday
-(4421) Made for TV
-(4422) Concert Films
-(4423) Music Documentaries
-(4424) Music Feature Films
-(4425) Japanese Cinema
-(4426) Jidaigeki
-(4427) Tokusatsu
-(4428) Korean Cinema
-```
-
-#### iTunes TV Genre IDs
-
-```sh
-AtomicParsley --genre-tv-id-list
-```
-
-```text
-(4000) Comedy
-(4001) Drama
-(4002) Animation
-(4003) Action & Adventure
-(4004) Classic
-(4005) Kids
-(4005) Nonfiction
-(4007) Reality TV
-(4008) Sci-Fi & Fantasy
-(4009) Sports
-(4010) Teens
-(4011) Latino TV
-```
-
-### Help
-
-Note: Normally we don't include full help text, but since AtomicParsley has a
-long history across various maintainers and repos, we feel it's appropriate to
-do so in this case.
-
-```text
-AtomicParsley sets metadata into MPEG-4 files & derivatives supporting 3 tag
- schemes: iTunes-style, 3GPP assets & ISO defined copyright notifications.
-
-AtomicParsley quick help for setting iTunes-style metadata into MPEG-4 files.
-
-General usage examples:
-  AtomicParsley /path/to.mp4 -T 1
-  AtomicParsley /path/to.mp4 -t +
-  AtomicParsley /path/to.mp4 --artist "Me" --artwork /path/to/art.jpg
-  Atomicparsley /path/to.mp4 --albumArtist "You" --podcastFlag true
-  Atomicparsley /path/to.mp4 --stik "TV Show" --advisory explicit
-
-Getting information about the file & tags:
-  -T  --test        Test file for mpeg4-ishness & print atom tree
-  -t  --textdata    Prints tags embedded within the file
-  -E  --extractPix  Extracts pix to the same folder as the mpeg-4 file
-
-Setting iTunes-style metadata tags
-  --artist       (string)     Set the artist tag
-  --title        (string)     Set the title tag
-  --album        (string)     Set the album tag
-  --genre        (string)     Genre tag (see --longhelp for more info)
-  --tracknum     (num)[/tot]  Track number (or track number/total tracks)
-  --disk         (num)[/tot]  Disk number (or disk number/total disks)
-  --comment      (string)     Set the comment tag
-  --year         (num|UTC)    Year tag (see --longhelp for "Release Date")
-  --lyrics       (string)     Set lyrics (not subject to 256 byte limit)
-  --lyricsFile   (/path)      Set lyrics to the content of a file
-  --composer     (string)     Set the composer tag
-  --copyright    (string)     Set the copyright tag
-  --grouping     (string)     Set the grouping tag
-  --artwork      (/path)      Set a piece of artwork (jpeg or png only)
-  --bpm          (number)     Set the tempo/bpm
-  --albumArtist  (string)     Set the album artist tag
-  --compilation  (boolean)    Set the compilation flag (true or false)
-  --hdvideo      (number)     Set the hdvideo flag to one of:
-                              false or 0 for standard definition
-                              true or 1 for 720p
-                              2 for 1080p
-  --advisory     (string*)    Content advisory (*values: 'clean', 'explicit')
-  --stik         (string*)    Sets the iTunes "stik" atom (see --longhelp)
-  --description  (string)     Set the description tag
-  --longdesc     (string)     Set the long description tag
-  --storedesc    (string)     Set the store description tag
-  --TVNetwork    (string)     Set the TV Network name
-  --TVShowName   (string)     Set the TV Show name
-  --TVEpisode    (string)     Set the TV episode/production code
-  --TVSeasonNum  (number)     Set the TV Season number
-  --TVEpisodeNum (number)     Set the TV Episode number
-  --podcastFlag  (boolean)    Set the podcast flag (true or false)
-  --category     (string)     Sets the podcast category
-  --keyword      (string)     Sets the podcast keyword
-  --podcastURL   (URL)        Set the podcast feed URL
-  --podcastGUID  (URL)        Set the episode's URL tag
-  --purchaseDate (UTC)        Set time of purchase
-  --encodingTool (string)     Set the name of the encoder
-  --encodedBy    (string)     Set the name of the Person/company who encoded the file
-  --apID         (string)     Set the Account Name
-  --cnID         (number)     Set the iTunes Catalog ID (see --longhelp)
-  --geID         (number)     Set the iTunes Genre ID (see --longhelp)
-  --xID          (string)     Set the vendor-supplied iTunes xID (see --longhelp)
-  --gapless      (boolean)    Set the gapless playback flag
-  --contentRating (string*)   Set tv/mpaa rating (see -rDNS-help)
-
-Deleting tags
-  Set the value to "":        --artist "" --stik "" --bpm ""
-  To delete (all) artwork:    --artwork REMOVE_ALL
-  manually removal:           --manualAtomRemove "moov.udta.meta.ilst.ATOM"
-
-More detailed iTunes help is available with AtomicParsley --longhelp
-Setting reverse DNS forms for iTunes files: see --reverseDNS-help
-Setting 3gp assets into 3GPP & derivative files: see --3gp-help
-Setting copyright notices for all files: see --ISO-help
-For file-level options & padding info: see --file-help
-Setting custom private tag extensions: see --uuid-help
-Setting ID3 tags onto mpeg-4 files: see --ID3-help
-
-----------------------------------------------------------------------
-AtomicParsley version: 20221229.172126.0 d813aa6e0304ed3ab6d92f1ae96cd52b586181ec (utf8)
-
-Submit bug fixes to https://github.com/wez/atomicparsley
-```
-
-### `--longhelp`
-
-```text
-AtomicParsley help page for setting iTunes-style metadata into MPEG-4 files.
-              (3gp help available with AtomicParsley --3gp-help)
-          (ISO copyright help available with AtomicParsley --ISO-help)
-      (reverse DNS form help available with AtomicParsley --reverseDNS-help)
-Usage: AtomicParsley [mp4FILE]... [OPTION]... [ARGUMENT]... [ [OPTION2]...[ARGUMENT2]...]
-
-example: AtomicParsley /path/to.mp4 -e ~/Desktop/pix
-example: AtomicParsley /path/to.mp4 --podcastURL "http://www.url.net" --tracknum 45/356
-example: AtomicParsley /path/to.mp4 --copyright "℗ © 2006"
-example: AtomicParsley /path/to.mp4 --year "2006-07-27T14:00:43Z" --purchaseDate timestamp
-example: AtomicParsley /path/to.mp4 --sortOrder artist "Mighty Dub Cats, The
-------------------------------------------------------------------------------------------------
-  Extract any pictures in user data "covr" atoms to separate files.
-  --extractPix       ,  -E                     Extract to same folder (basename derived from file).
-  --extractPixToPath ,  -e  (/path/basename)   Extract to specific path (numbers added to basename).
-                                                 example: --e ~/Desktop/SomeText
-                                                 gives: SomeText_artwork_1.jpg  SomeText_artwork_2.png
-                                               Note: extension comes from embedded image file format
-------------------------------------------------------------------------------------------------
- Tag setting options:
-
-  --artist           ,  -a   (str)    Set the artist tag: "moov.udta.meta.ilst.©ART.data"
-  --title            ,  -s   (str)    Set the title tag: "moov.udta.meta.ilst.©nam.data"
-  --album            ,  -b   (str)    Set the album tag: "moov.udta.meta.ilst.©alb.data"
-  --genre            ,  -g   (str)    Set the genre tag: "©gen" (custom) or "gnre" (standard).
-                                          see the standard list with "AtomicParsley --genre-list"
-  --tracknum         ,  -k   (num)[/tot]  Set the track number (or track number & total tracks).
-  --disk             ,  -d   (num)[/tot]  Set the disk number (or disk number & total disks).
-  --comment          ,  -c   (str)    Set the comment tag: "moov.udta.meta.ilst.©cmt.data"
-  --year             ,  -y   (num|UTC)    Set the year tag: "moov.udta.meta.ilst.©day.data"
-                                          set with UTC "2006-09-11T09:00:00Z" for Release Date
-  --lyrics           ,  -l   (str)    Set the lyrics tag: "moov.udta.meta.ilst.©lyr.data"
-  --lyricsFile       ,       (/path)  Set the lyrics tag to the content of a file
-  --composer         ,  -w   (str)    Set the composer tag: "moov.udta.meta.ilst.©wrt.data"
-  --copyright        ,  -x   (str)    Set the copyright tag: "moov.udta.meta.ilst.cprt.data"
-  --grouping         ,  -G   (str)    Set the grouping tag: "moov.udta.meta.ilst.©grp.data"
-  --artwork          ,  -A   (/path)  Set a piece of artwork (jpeg or png) on "covr.data"
-                                          Note: multiple pieces are allowed with more --artwork args
-  --bpm              ,  -B   (num)    Set the tempo/bpm tag: "moov.udta.meta.ilst.tmpo.data"
-  --albumArtist      ,  -A   (str)    Set the album artist tag: "moov.udta.meta.ilst.aART.data"
-  --compilation      ,  -C   (bool)   Sets the "cpil" atom (true or false to delete the atom)
-  --hdvideo          ,  -V   (bool)   Sets the "hdvd" atom (true or false to delete the atom)
-  --advisory         ,  -y   (1of3)   Sets the iTunes lyrics advisory ('remove', 'clean', 'explicit')
-  --stik             ,  -S   (1of7)   Sets the iTunes "stik" atom (--stik "remove" to delete)
-                                           "Movie", "Normal", "TV Show" .... others:
-                                           see the full list with "AtomicParsley --stik-list"
-                                           or set in an integer value with --stik value=(num)
-                                      Note: --stik Audiobook will change file extension to '.m4b'
-  --description      ,  -p   (str)    Sets the description on the "desc" atom
-  --Rating           ,       (str)    Sets the Rating on the "rate" atom
-  --longdesc         ,  -j   (str)    Sets the long description on the "ldes" atom
-  --storedesc        ,       (str)    Sets the iTunes store description on the "sdes" atom
-  --TVNetwork        ,  -n   (str)    Sets the TV Network name on the "tvnn" atom
-  --TVShowName       ,  -H   (str)    Sets the TV Show name on the "tvsh" atom
-  --TVEpisode        ,  -I   (str)    Sets the TV Episode on "tven":"209", but it is a string: "209 Part 1"
-  --TVSeasonNum      ,  -U   (num)    Sets the TV Season number on the "tvsn" atom
-  --TVEpisodeNum     ,  -N   (num)    Sets the TV Episode number on the "tves" atom
-  --podcastFlag      ,  -f   (bool)   Sets the podcast flag (values are "true" or "false")
-  --category         ,  -q   (str)    Sets the podcast category; typically a duplicate of its genre
-  --keyword          ,  -K   (str)    Sets the podcast keyword; invisible to MacOSX Spotlight
-  --podcastURL       ,  -L   (URL)    Set the podcast feed URL on the "purl" atom
-  --podcastGUID      ,  -J   (URL)    Set the episode's URL tag on the "egid" atom
-  --purchaseDate     ,  -D   (UTC)    Set Universal Coordinated Time of purchase on a "purd" atom
-                                       (use "timestamp" to set UTC to now; can be akin to id3v2 TDTG tag)
-  --encodingTool     ,       (str)    Set the name of the encoder on the "©too" atom
-  --encodedBy        ,       (str)    Set the name of the Person/company who encoded the file on the "©enc" atom
-  --apID             ,  -Y   (str)    Set the name of the Account Name on the "apID" atom
-  --cnID             ,       (num)    Set iTunes Catalog ID, used for combining SD and HD encodes in iTunes on the "cnID" atom
-
-                                      To combine you must set "hdvd" atom on one file and must have same "stik" on both file
-                                      Must not use "stik" of value Home Video(0), use Movie(9)
-
-                                      iTunes Catalog numbers can be obtained by finding the item in the iTunes Store.  Once item
-                                      is found in the iTunes Store right click on picture of item and select copy link.  Paste this link
-                                      into a document or web browser to display the catalog number ID.
-
-                                      An example link for the video Street Kings is:
-                                      http://itunes.apple.com/WebObjects/MZStore.woa/wa/viewMovie?id=278743714&s=143441
-                                      Here you can see the cnID is 278743714
-
-                                      Alternatively you can use iMDB numbers, however these will not match the iTunes catalog.
-
-  --geID             ,       (num)    Set iTunes Genre ID.  This does not necessarily have to match genre.
-                                      See --genre-movie-id-list and --genre-tv-id-list
-
-  --xID              ,       (str)    Set iTunes vendor-supplied xID, used to allow iTunes LPs and iTunes Extras to interact
-                                            with other content in your iTunes Library
-  --gapless          ,       (bool)   Sets the gapless playback flag for a track in a gapless album
-  --sortOrder    (type)      (str)    Sets the sort order string for that type of tag.
-                                       (available types are: "name", "artist", "albumartist",
-                                        "album", "composer", "show")
-
-NOTE: Except for artwork, only 1 of each tag is allowed; artwork allows multiple pieces.
-NOTE: Tags that carry text(str) have a limit of 255 utf8 characters;
-however lyrics and long descriptions have no limit.
-------------------------------------------------------------------------------------------------
- To delete a single atom, set the tag to null (except artwork):
-  --artist "" --lyrics ""
-  --artwork REMOVE_ALL
-  --metaEnema        ,  -P            Douches away every atom under "moov.udta.meta.ilst"
-  --foobar2000Enema  ,  -2            Eliminates foobar2000's non-compliant so-out-o-spec tagging scheme
-  --manualAtomRemove "some.atom.path" where some.atom.path can be:
-      keys to using manualAtomRemove:
-         ilst.ATOM.data or ilst.ATOM target an iTunes-style metadata tag
-         ATOM:lang=foo               target an atom with this language setting; like 3gp assets
-         ATOM.----.name:[foo]        target a reverseDNS metadata tag; like iTunNORM
-                                     Note: these atoms show up with 'AP -t' as: Atom "----" [foo]
-                                         'foo' is actually carried on the 'name' atom
-         ATOM[x]                     target an atom with an index other than 1; like trak[2]
-         ATOM.uuid=hex-hex-hex-hex   targt a uuid atom with the uuid of hex string representation
-    examples:
-        moov.udta.meta.ilst.----.name:[iTunNORM]      moov.trak[3].cprt:lang=urd
-        moov.trak[2].uuid=55534d54-21d2-4fce-bb88-695cfac9c740
-------------------------------------------------------------------------------------------------
-                   Environmental Variables (affecting picture placement) (macOS ONLY)
-
-  set PIC_OPTIONS in your shell to set these flags; preferences are separated by colons (:)
-
- MaxDimensions=num (default: 0; unlimited); sets maximum pixel dimensions
- DPI=num           (default: 72); sets dpi
- MaxKBytes=num     (default: 0; unlimited);  maximum kilobytes for file (jpeg only)
- AddBothPix=bool   (default: false); add original & converted pic (for archival purposes)
- AllPixJPEG | AllPixPNG =bool (default: false); force conversion to a specific picture format
- SquareUp          (include to square images to largest dimension, allows an [ugly] 160x1200->1200x1200)
- removeTempPix     (include to delete temp pic files created when resizing images after tagging)
- ForceHeight=num   (must also specify width, below) force image pixel height
- ForceWidth=num    (must also specify height, above) force image pixel width
-
- Examples: (bash-style)
- export PIC_OPTIONS="MaxDimensions=400:DPI=72:MaxKBytes=100:AddBothPix=true:AllPixJPEG=true"
- export PIC_OPTIONS="SquareUp:removeTempPix"
- export PIC_OPTIONS="ForceHeight=999:ForceWidth=333:removeTempPix"
-------------------------------------------------------------------------------------------------
-```
-
-```
-
-```

atomicparsley/install.ps1

@@ -1,60 +0,0 @@
-#!/usr/bin/env pwsh
-
-#########################
-# Install AtomicParsley #
-#########################
-
-# Every package should define these variables
-$pkg_cmd_name = "AtomicParsley"
-
-$pkg_dst_cmd = "$Env:USERPROFILE\.local\bin\AtomicParsley.exe"
-$pkg_dst_bin = "$Env:USERPROFILE\.local\bin"
-$pkg_dst = "$pkg_dst_cmd"
-
-$pkg_src_cmd = "$Env:USERPROFILE\.local\opt\AtomicParsley-v$Env:WEBI_VERSION\bin\AtomicParsley.exe"
-$pkg_src_bin = "$Env:USERPROFILE\.local\opt\AtomicParsley-v$Env:WEBI_VERSION\bin"
-$pkg_src_dir = "$Env:USERPROFILE\.local\opt\AtomicParsley-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 "Checking for (or Installing) MSVC Runtime..."
-    & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
-
-    Write-Output "Downloading AtomicParsley 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 AtomicParsley"
-
-    # TODO: create package-specific temp directory
-    # Enter tmp
-    Push-Location .local\tmp
-
-    # Remove any leftover tmp cruft
-    Remove-Item -Path ".\AtomicParsley-v*" -Recurse -ErrorAction Ignore
-    Remove-Item -Path ".\AtomicParsley.exe" -Recurse -ErrorAction Ignore
-
-    # Unpack archive file into this temporary directory
-    # Windows BSD-tar handles zip. Imagine that.
-    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 ".\AtomicParsley.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
-New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
-Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

atomicparsley/install.sh

@@ -1,41 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-
-__init_atomicparsley() {
-
-    #########################
-    # Install AtomicParsley #
-    #########################
-
-    WEBI_SINGLE=true
-
-    # Every package should define these 6 variables
-    pkg_cmd_name="AtomicParsley"
-
-    pkg_dst_cmd="$HOME/.local/bin/AtomicParsley"
-    pkg_dst="$pkg_dst_cmd"
-
-    pkg_src_cmd="$HOME/.local/opt/AtomicParsley-v$WEBI_VERSION/bin/AtomicParsley"
-    pkg_src_dir="$HOME/.local/opt/AtomicParsley-v$WEBI_VERSION"
-    pkg_src="$pkg_src_cmd"
-
-    # pkg_install must be defined by every package
-    pkg_install() {
-        # ~/.local/opt/AtomicParsley-v20221229.172126.0/bin
-        mkdir -p "$(dirname "$pkg_src_cmd")"
-
-        # mv ./AtomicParsley ~/.local/opt/AtomicParsley-v20221229.172126.0/bin/AtomicParsley
-        mv ./"$pkg_cmd_name" "$pkg_src_cmd"
-    }
-
-    pkg_get_current_version() {
-        # 'AtomicParsley --version' has output in this format:
-        #       AtomicParsley version: 20221229.172126.0 d813aa6e0304ed3ab6d92f1ae96cd52b586181ec (utf8)
-        # This trims it down to just the version number:
-        #       20221229.172126.0
-        AtomicParsley --version 2> /dev/null | head -n 1 | cut -d' ' -f3
-    }
-}
-
-__init_atomicparsley

atomicparsley/releases.conf

@@ -1 +0,0 @@
-github_releases = wez/atomicparsley

awless/README.md

@@ -7,23 +7,12 @@ tagline: |
 
 To update or switch versions, run `webi awless@stable` (or `@v2`, `@beta`, etc).
 
-### Files
-
-These are the files / directories that are created and/or modified with this
-install:
-
-```text
-~/.config/envman/PATH.env
-~/.local/bin/awless
-~/.aws/credentials
-```
-
 ## Cheat Sheet
 
 awless is modeled after popular command-line tools such as Git. Most commands
 are in the form of:
 
-```sh
+```bash
 awless verb [entity] [parameter=value ...]
 ```
 
@@ -37,13 +26,13 @@ Unlike the standard awscli tools, `awless` aims to be more human readable.
 
 For instance, let's list some resources:
 
-```sh
+```bash
 awless list vpcs
 ```
 
 Which outputs a friendly human readable table!
 
-```sh
+```bash
 |         ID ▲          | NAME | DEFAULT |   STATE   |     CIDR      |
 |-----------------------|------|---------|-----------|---------------|
 | vpc-00fd208a070000000 |      | false   | available | 172.16.0.0/16 |
@@ -53,13 +42,13 @@ Which outputs a friendly human readable table!
 There's also filter capabilities, in case the list is long. For example, let's
 list all EC2 instances with "api" in the name:
 
-```sh
+```bash
 awless list instances --filter name=api
 ```
 
 In addition to the default table output, there's also csv, tsv, json.
 
-```sh
+```bash
 awless list loadbalancers --format csv
 ```
 
@@ -67,7 +56,7 @@ awless list loadbalancers --format csv
 
 awless allows specifying things by name rather than ID by using the `@` prefix.
 
-```sh
+```bash
 awless create subnet cidr=10.0.0.0/24 vpc=@wordpress-vpc name=wordpress-public-subnet
 ```
 
@@ -76,13 +65,13 @@ awless create subnet cidr=10.0.0.0/24 vpc=@wordpress-vpc name=wordpress-public-s
 If you leave out a parameter, awless will prompt you for the missing
 information.
 
-```sh
+```bash
 awless delete i-123456789000abcd
 ```
 
 It will correctly detect what you were probably trying to do:
 
-```sh
+```bash
 Did you mean `awless delete instance ids=i-051fcef0537a53eb0` ?  [Y/n]
 ```
 

awless/install.ps1

@@ -16,22 +16,22 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\awless-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\awless-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"
+$pkg_download = "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE"
 
 # Fetch archive
-if (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
-    Write-Output "Downloading awless from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\$Env:WEBI_PKG_FILE")) {
+    # TODO: arch detection
+    echo "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"
+    & move "$pkg_download.part" "$pkg_download"
 }
 
-if (!(Test-Path -Path "$pkg_src_cmd")) {
-    Write-Output "Installing awless"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    echo "Installing awless"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    Push-Location .local\tmp
+    pushd .local\tmp
 
     # Remove any leftover tmp cruft
     Remove-Item -Path ".\awless-v*" -Recurse -ErrorAction Ignore
@@ -39,19 +39,19 @@ if (!(Test-Path -Path "$pkg_src_cmd")) {
 
     # Unpack archive file into this temporary directory
     # Windows BSD-tar handles zip. Imagine that.
-    Write-Output "Unpacking $pkg_download"
+    echo "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
+    echo "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
     Move-Item -Path ".\awless.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    Pop-Location
+    popd
 }
 
-Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
-New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
+echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+New-Item "$pkg_dst_bin" -ItemType Directory -Force | out-null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

awless/install.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 
 # "This is too simple" you say! "Where is the magic!?" you ask.
 # There is no magic!
@@ -19,7 +19,7 @@ pkg_get_current_version() {
     #       v2.1.0 h1:pQSaIJGFluFvu8KDGDODV8u4/QRED/OPyIR+MWYYse8=
     # This trims it down to just the version number:
     #       2.1.0
-    awless version 2> /dev/null | head -n 1 | cut -d' ' -f1 | sed 's:^v::'
+    echo "$(awless version 2> /dev/null | head -n 1 | cut -d' ' -f1 | sed 's:^v::')"
 }
 
 pkg_install() {

awless/releases.conf

@@ -1 +0,0 @@
-github_releases = wallix/awless

awless/releases.js

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