doc: show example formatted 'installer' string

Signed-off-by: starvader13 <ashutoshgupta1311@gmail.com>

.github/workflows/node.js.yml

@@ -22,6 +22,7 @@ jobs:
         run: |
           sh ./_scripts/install-ci-deps
           echo "${HOME}/.local/bin" >> $GITHUB_PATH
+          echo "${HOME}/.local/opt/pwsh" >> $GITHUB_PATH
       - run: shfmt --version
       - run: shellcheck -V
       - run: node --version

.vimrc

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

AtomicParsley

@@ -1 +0,0 @@
-atomicparsley

_example/install.ps1

@@ -15,47 +15,45 @@ $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
+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"))
-{
-    echo "Downloading foobar from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading foobar from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing foobar"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing foobar"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .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.
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    # 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
-        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"
+    # 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"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

_scripts/git-hooks-init.js

@@ -0,0 +1,57 @@
+#!/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

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

_scripts/git-hooks-pre-commit.js

@@ -0,0 +1,12 @@
+#!/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

@@ -7,3 +7,9 @@ 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

@@ -0,0 +1,27 @@
+#!/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

@@ -0,0 +1,40 @@
+#!/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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,48 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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/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
+    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"

_webi/bootstrap.ps1

@@ -4,9 +4,9 @@
 # <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 ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
+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/bootstrap.sh

@@ -15,12 +15,12 @@ __install_webi() {
     export WEBI_HOST
 
     echo ""
-    printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[31m%s/%s\e[0m'.\n" "${WEBI_PKG-}" "$(uname -s)/$(uname -r)" "$(uname -m)"
+    printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[33m%s/%s\e[0m'.\n" "${WEBI_PKG-}" "$(uname -s)/$(uname -r)" "$(uname -m)"
     echo "Have a problem? Experience a bug? Please let us know:"
-    echo "        https://github.com/webinstall/webi-installers/issues"
+    printf "        \e[2m\e[36mhttps://github.com/webinstall/webi-installers/issues\e[0m\n"
     echo ""
-    printf "\e[31mLovin'\e[0m it? Say thanks with a \e[34mStar on GitHub\e[0m:\n"
-    printf "        \e[32mhttps://github.com/webinstall/webi-installers\e[0m\n"
+    printf "\e[35mLovin'\e[0m it? Say thanks with a \e[1m\e[33mStar on GitHub\e[0m:\n"
+    printf "        \e[36mhttps://github.com/webinstall/webi-installers\e[0m\n"
     echo ""
 
     WEBI_WELCOME=true
@@ -145,9 +145,9 @@ __webi_main() {
                     printf 'PATH.env updated with:\\n'
                     printf "%s\\n" "\$my_paths"
                     printf '\\n'
-                    printf "\\e[31mTO FINISH\\e[0m: copy, paste & run the following command:\\n"
+                    printf "\\e[1m\\e[35mTO FINISH\\e[0m: copy, paste & run the following command:\\n"
                     printf "\\n"
-                    printf "        \\e[34msource ~/.config/envman/PATH.env\\e[0m\\n"
+                    printf "        \\e[1m\\e[32msource ~/.config/envman/PATH.env\\e[0m\\n"
                     printf "        (newly opened terminal windows will update automatically)\\n"
                 fi
                 rm -f "\$_webi_tmp/.PATH.env"
@@ -158,8 +158,8 @@ __webi_main() {
 
     version() {
         my_version=v1.1.15
-        printf "\\e[31mwebi\\e[32m %s\\e[0m Copyright 2020+ AJ ONeal\\n" "\${my_version}"
-        printf "    \\e[34mhttps://webinstall.dev/webi\\e[0m\\n"
+        printf "\\e[35mwebi\\e[32m %s\\e[0m Copyright 2020+ AJ ONeal\\n" "\${my_version}"
+        printf "    \\e[36mhttps://webinstall.dev/webi\\e[0m\\n"
     }
 
     # show help if no params given or help flags are used

_webi/releases.js

@@ -5,6 +5,8 @@ var path = require('node:path');
 var request = require('@root/request');
 var _normalize = require('../_webi/normalize.js');
 
+// PowerShell: { { installer } }
+// POSIX:      {{ installer }}
 var reInstallTpl = /\s*#?\s*{{ installer }}/;
 
 var Releases = module.exports;

_webi/template.ps1

@@ -1,13 +1,13 @@
-#!/usr/bin/env pwsh
+#!/usr/bin/env pwsh
 #350 check if windows user run as admin
 
 function Confirm-IsElevated {
-	$id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
-	$p = New-Object System.Security.Principal.WindowsPrincipal($id)
-	if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
-	{ Write-Output $true }
-	else
-	{ Write-Output $false }
+    $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
+    $p = New-Object System.Security.Principal.WindowsPrincipal($id)
+    if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
+    { Write-Output $true }
+    else
+    { Write-Output $false }
 }
 
 if (Confirm-IsElevated)
@@ -32,18 +32,17 @@ $Env:WEBI_HOST = 'https://webinstall.dev'
 #$Env:WEBI_PKG_FILE = "node-v12.16.2-win-x64.zip"
 
 # Switch to userprofile
-pushd $Env:USERPROFILE
+Push-Location $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
+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_path_add($pathname)
-{
+function webi_path_add($pathname) {
     # C:\Users\me => C:/Users/me
     $my_home = $Env:UserProfile
     $my_home = $my_home.replace('\\', '/')
@@ -57,41 +56,35 @@ function webi_path_add($pathname)
     $my_pathname = $my_pathname -ireplace $my_home_re, "%USERPROFILE%"
 
     $all_user_paths = [Environment]::GetEnvironmentVariable("Path", "User")
-    $user_paths = $all_user_paths -Split(';')
+    $user_paths = $all_user_paths -Split (';')
     $exists_in_path = $false
-    foreach ($user_path in $user_paths)
-    {
+    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)
-        {
+        if ($my_user_path -ieq $my_pathname) {
             $exists_in_path = $true
         }
     }
-    if (-Not $exists_in_path)
-    {
+    if (-Not $exists_in_path) {
         $all_user_paths = $pathname + ";" + $all_user_paths
         [Environment]::SetEnvironmentVariable("Path", $all_user_paths, "User")
     }
 
-    $session_paths = $Env:Path -Split(';')
+    $session_paths = $Env:Path -Split (';')
     $in_session_path = $false
-    foreach ($session_path in $session_paths)
-    {
+    foreach ($session_path in $session_paths) {
         # C:\Users\me\bin => %USERPROFILE%/bin
         $my_session_path = $session_path.replace('\\', '/')
         $my_session_path = $my_session_path -ireplace $my_home_re, "%USERPROFILE%"
 
-        if ($my_session_path -ieq $my_pathname)
-        {
+        if ($my_session_path -ieq $my_pathname) {
             $in_session_path = $true
         }
     }
 
-    if (-Not $in_session_path)
-    {
+    if (-Not $in_session_path) {
         $my_cmd = 'PATH ' + "$pathname" + ';%PATH%'
         $my_pwsh = '$Env:Path = "' + "$pathname" + ';$Env:Path"'
 
@@ -101,28 +94,28 @@ function webi_path_add($pathname)
         Write-Host '*  (run the PATH command below)  *' -ForegroundColor red -BackgroundColor white
         Write-Host '**********************************' -ForegroundColor red -BackgroundColor white
         Write-Host ''
-        echo ""
-        echo "Copy, paste, and run the appropriate command to update your PATH:"
-        echo "(or close and reopen the terminal, or reboot)"
-        echo ""
-        echo "cmd.exe:"
-        echo "    $my_cmd"
-        echo ""
-        echo "PowerShell:"
-        echo "    $my_pwsh"
-        echo ""
+        Write-Output ""
+        Write-Output "Copy, paste, and run the appropriate command to update your PATH:"
+        Write-Output "(or close and reopen the terminal, or reboot)"
+        Write-Output ""
+        Write-Output "cmd.exe:"
+        Write-Output "    $my_cmd"
+        Write-Output ""
+        Write-Output "PowerShell:"
+        Write-Output "    $my_pwsh"
+        Write-Output ""
     }
 }
 
 #$has_local_bin = echo "$Env:PATH" | Select-String -Pattern '\.local.bin'
 #if (!$has_local_bin)
 #{
-    webi_path_add ~/.local/bin
+webi_path_add ~/.local/bin
 #}
 
-{{ installer }}
+# {{ installer }}
 
 webi_path_add ~/.local/bin
 
 # Done
-popd
+Pop-Location

_webi/template.sh

@@ -508,12 +508,12 @@ __bootstrap_webi() {
 
     if [ -z "${WEBI_WELCOME-}" ]; then
         echo ""
-        printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[31m%s/%s\e[0m'.\n" "${WEBI_PKG-}" "$(uname -s)" "$(uname -m)"
+        printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[33m%s/%s\e[0m'.\n" "${WEBI_PKG-}" "$(uname -s)" "$(uname -m)"
         echo "Have a problem? Experience a bug? Please let us know:"
-        echo "        https://github.com/webinstall/webi-installers/issues"
+        printf "        \e[2m\e[36mhttps://github.com/webinstall/webi-installers/issues\e[0m\n"
         echo ""
-        printf "\e[31mLovin'\e[0m it? Say thanks with a \e[34mStar on GitHub\e[0m:\n"
-        printf "        \e[32mhttps://github.com/webinstall/webi-installers\e[0m\n"
+        printf "\e[35mLovin'\e[0m it? Say thanks with a \e[1m\e[33mStar on GitHub\e[0m:\n"
+        printf "        \e[36mhttps://github.com/webinstall/webi-installers\e[0m\n"
         echo ""
     fi
 
@@ -608,9 +608,9 @@ __bootstrap_webi() {
 
             rm -f "$_webi_tmp/.PATH.env"
 
-            printf "\e[31mTO FINISH\e[0m: copy, paste & run the following command:\n"
+            printf "\e[1m\e[35mTO FINISH\e[0m: copy, paste & run the following command:\n"
             printf "\n"
-            printf "        \e[34msource ~/.config/envman/PATH.env\e[0m\n"
+            printf "        \e[1m\e[32msource ~/.config/envman/PATH.env\e[0m\n"
             printf "        (newly opened terminal windows will update automatically)\n"
         fi
     fi

_webi/webi-pwsh.ps1

@@ -1,4 +1,4 @@
-#!/usr/bin/env pwsh
+#!/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
@@ -14,8 +14,8 @@ $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"
+    # This is the canonical CPU arch when the process is native
+    $my_arch = "$Env:PROCESSOR_ARCHITECTURE"
 }
 IF ($my_arch -eq "AMD64") {
     # Because PowerShell isn't ARM yet.
@@ -32,31 +32,28 @@ $Env:WEBI_UA = "Windows/10 $my_arch"
 $exename = $args[0]
 
 # Switch to userprofile
-pushd $Env:USERPROFILE
+Push-Location $Env:USERPROFILE
 
 # Make paths if needed
-New-Item -Path .local\bin -ItemType Directory -Force | out-null
+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
+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
+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
+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 "")
-{
+IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") {
     $Env:WEBI_HOST = "https://webinstall.dev"
 }
 
@@ -66,32 +63,32 @@ IF($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "")
 $my_version = 'v1.1.15'
 
 ## show help if no params given or help flags are used
-if ($exename -eq $null -or $exename -eq "-h" -or $exename -eq "--help" -or $exename -eq "help" -or $exename -eq "/?") {
+if ($null -eq $exename -or $exename -eq "-h" -or $exename -eq "--help" -or $exename -eq "help" -or $exename -eq "/?") {
     Write-Host "webi " -ForegroundColor Green -NoNewline; Write-Host "$my_version " -ForegroundColor Red -NoNewline; Write-Host "Copyright 2020+ AJ ONeal"
     Write-Host "  https://webinstall.dev/webi" -ForegroundColor blue
-    echo ""
-    echo "SUMMARY"
-    echo "    Webi is the best way to install the modern developer tools you love."
-    echo "    It's fast, easy-to-remember, and conflict free."
-    echo ""
-    echo "USAGE"
-    echo "    webi <thing1>[@version] [thing2] ..."
-    echo ""
-    echo "UNINSTALL"
-    echo "    Almost everything that is installed with webi is scoped to"
-    echo "    ~/.local/opt/<thing1>, so you can remove it like so:"
-    echo ""
-    echo "    rmdir /s %USERPROFILE%\.local\opt\<thing1>"
-    echo "    del %USERPROFILE%\.local\bin\<thing1>"
-    echo ""
-    echo "    Some packages have special uninstall instructions, check"
-    echo "    https://webinstall.dev/<thing1> to be sure."
-    echo ""
-    echo "FAQ"
+    Write-Output ""
+    Write-Output "SUMMARY"
+    Write-Output "    Webi is the best way to install the modern developer tools you love."
+    Write-Output "    It's fast, easy-to-remember, and conflict free."
+    Write-Output ""
+    Write-Output "USAGE"
+    Write-Output "    webi <thing1>[@version] [thing2] ..."
+    Write-Output ""
+    Write-Output "UNINSTALL"
+    Write-Output "    Almost everything that is installed with webi is scoped to"
+    Write-Output "    ~/.local/opt/<thing1>, so you can remove it like so:"
+    Write-Output ""
+    Write-Output "    rmdir /s %USERPROFILE%\.local\opt\<thing1>"
+    Write-Output "    del %USERPROFILE%\.local\bin\<thing1>"
+    Write-Output ""
+    Write-Output "    Some packages have special uninstall instructions, check"
+    Write-Output "    https://webinstall.dev/<thing1> to be sure."
+    Write-Output ""
+    Write-Output "FAQ"
     Write-Host "    See " -NoNewline; Write-Host "https://webinstall.dev/faq" -ForegroundColor blue
-    echo ""
-    echo "ALWAYS REMEMBER"
-    echo "    Friends don't let friends use brew for simple, modern tools that don't need it."
+    Write-Output ""
+    Write-Output "ALWAYS REMEMBER"
+    Write-Output "    Friends don't let friends use brew for simple, modern tools that don't need it."
     exit 0
 }
 
@@ -104,7 +101,7 @@ if ($exename -eq "-V" -or $exename -eq "--version" -or $exename -eq "version" -o
 # Fetch <whatever>.ps1
 # TODO detect formats
 $PKG_URL = "$Env:WEBI_HOST/api/installers/$exename.ps1?formats=zip,exe,tar"
-echo "Downloading $PKG_URL"
+Write-Output "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
 
@@ -112,4 +109,4 @@ echo "Downloading $PKG_URL"
 powershell .\.local\tmp\$exename.install.ps1
 
 # Done
-popd
+Pop-Location

arc/README.md

@@ -9,9 +9,12 @@ To update or switch versions, run `webi arc@stable` (or `@v3.5`, `@beta`, etc).
 
 ### Files
 
+These are the files / directories that are created and/or modified with this
+install:
+
 ```text
 ~/.config/envman/PATH.env
-~/.local/opt/archiver/
+~/.local/bin/arc
 ```
 
 ## Cheat Sheet

arc/install.ps1

@@ -15,41 +15,39 @@ $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
+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"))
-{
-    echo "Downloading archiver from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading archiver from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing archiver"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing archiver"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .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 "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "arc.exe"
+    # Move single binary into root of temporary folder
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "arc.exe"
 
-        # 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"
+    # 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"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

archiver/install.ps1

@@ -1,5 +1,5 @@
 #!/bin/pwsh
 
-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" }
+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 -fsSL "$Env:WEBI_HOST/arc@$Env:WEBI_VERSION" | powershell

atomicparsley/README.md

@@ -34,7 +34,7 @@ fails and you get the error _`vcruntime140.dll` was not found_, you'll need to
 > `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 - like adding album artwork.
+> can do some things `ffmpeg` can't.
 
 ### How to Change Album Art
 
@@ -46,7 +46,7 @@ fails and you get the error _`vcruntime140.dll` was not found_, you'll need to
    ```sh
    AtomicParsley ./my-song.m4a --artwork REMOVE_ALL
    ```
-3. Add new artwork at the specified DPI (and other constraints)
+3. **(macOS ONLY)** Add new artwork at the specified DPI (and other constraints)
 
    ```sh
    export PIC_OPTIONS="DPI=72"
@@ -512,7 +512,7 @@ however lyrics and long descriptions have no limit.
         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)
+                   Environmental Variables (affecting picture placement) (macOS ONLY)
 
   set PIC_OPTIONS in your shell to set these flags; preferences are separated by colons (:)
 

atomicparsley/install.ps1

@@ -16,25 +16,25 @@ $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
+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")) {
-    echo "Checking for (or Installing) MSVC Runtime..."
+    Write-Output "Checking for (or Installing) MSVC Runtime..."
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
 
-    echo "Downloading AtomicParsley from $Env:WEBI_PKG_URL to $pkg_download"
+    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 "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
 IF (!(Test-Path -Path "$pkg_src_cmd")) {
-    echo "Installing AtomicParsley"
+    Write-Output "Installing AtomicParsley"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
     # Remove any leftover tmp cruft
     Remove-Item -Path ".\AtomicParsley-v*" -Recurse -ErrorAction Ignore
@@ -42,19 +42,19 @@ IF (!(Test-Path -Path "$pkg_src_cmd")) {
 
     # Unpack archive file into this temporary directory
     # Windows BSD-tar handles zip. Imagine that.
-    echo "Unpacking $pkg_download"
+    Write-Output "Unpacking $pkg_download"
     & tar xf "$pkg_download"
 
     # Settle unpacked archive into place
-    echo "Install Location: $pkg_src_cmd"
-    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+    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
-    popd
+    Pop-Location
 }
 
-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
+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

awless/README.md

@@ -7,6 +7,17 @@ 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

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
+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")) {
-    echo "Downloading awless from $Env:WEBI_PKG_URL to $pkg_download"
+    Write-Output "Downloading awless from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
 IF (!(Test-Path -Path "$pkg_src_cmd")) {
-    echo "Installing awless"
+    Write-Output "Installing awless"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .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.
-    echo "Unpacking $pkg_download"
+    Write-Output "Unpacking $pkg_download"
     & tar xf "$pkg_download"
 
     # Settle unpacked archive into place
-    echo "Install Location: $pkg_src_cmd"
-    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+    Write-Output "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
-    popd
+    Pop-Location
 }
 
-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
+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

bat/README.md

@@ -9,26 +9,31 @@ To update or switch versions, run `webi bat@stable` (or `@v0.18`, `@beta`, etc).
 
 ### Files
 
+These are the files / directories that are created and/or modified with this
+install:
+
 ```text
 ~/.config/envman/PATH.env
 ~/.config/bat/config
 ~/.local/opt/bat/
 ```
 
+**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
 
 > `bat` is pretty much what `cat` would be if it were developed today's in the
 > world of Markdown, git, etc.
 
-### How to run on Windows
-
-On Windows you'll get an error like this:
-
-> execution cannot proceed run because vcruntime140.dll was not found
-
-You need to download and install the
-[Microsoft Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)
-
 ### How to alias as `cat`
 
 Use [aliasman](/aliasman):

bat/install.ps1

@@ -3,41 +3,45 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+# Fetch MSVC Runtime
+Write-Output "Checking for MSVC Runtime..."
+IF (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
+    & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
+}
+
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        # Move single binary into root of temporary folder
-        & move "bat-*\$EXENAME" "$VERNAME"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Move single binary into root of temporary folder
+    & Move-Item "bat-*\$EXENAME" "$VERNAME"
 
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

brew/README.md

@@ -5,13 +5,24 @@ tagline: |
   Brew: The Missing Package Manager for macOS (and Linux).
 ---
 
-## Updating `brew`
-
-`brew` has its own built-in upgrade management.
+To update or switch versions, use brew's built-in upgrade management, or our
+handy update service script:
 
 ```sh
 brew update
 brew upgrade
+brew-update-service-install # Webi helper script
+```
+
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/opt/brew/
+~/.local/bin/brew-update-service-install
 ```
 
 ## Cheat Sheet

caddy/README.md

@@ -8,6 +8,19 @@ tagline: |
 To update or switch versions, run `webi caddy@stable` (or `@v2.4`, `@beta`,
 etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/caddy
+~/.config/caddy/autosave.json
+~/.local/share/caddy/certificates/
+<PROJECT-DIR>/Caddyfile
+```
+
 ## Cheat Sheet
 
 > Caddy makes it easy to use Let's Encrypt to handle HTTPS (TLS/SSL) and to

caddy/install.ps1

@@ -16,22 +16,22 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\caddy-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\caddy-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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")) {
-    echo "Downloading caddy from $Env:WEBI_PKG_URL to $pkg_download"
+    Write-Output "Downloading caddy from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
 IF (!(Test-Path -Path "$pkg_src_cmd")) {
-    echo "Installing caddy"
+    Write-Output "Installing caddy"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
     # Remove any leftover tmp cruft
     Remove-Item -Path ".\caddy-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.
-    echo "Unpacking $pkg_download"
+    Write-Output "Unpacking $pkg_download"
     & tar xf "$pkg_download"
 
     # Settle unpacked archive into place
-    echo "Install Location: $pkg_src_cmd"
-    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
     Move-Item -Path ".\caddy.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-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
+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

chromedriver/install.ps1

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

cmake/install.ps1

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

comrak/README.md

@@ -8,6 +8,17 @@ tagline: |
 To update or switch versions, run `webi comrak@stable` (or `@v0.11`, `@beta`,
 etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/comrak
+~/.config/comrak/config
+```
+
 ## Cheat Sheet
 
 > Comrak supports the five extensions to CommonMark defined in the GitHub

comrak/install.ps1

@@ -3,37 +3,35 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Move single binary into root of temporary folder
-        & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "$VERNAME"
+    # Move single binary into root of temporary folder
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "$VERNAME"
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME"
-        New-Item "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin" -ItemType Directory -Force | out-null
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME"
+    New-Item "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin" -ItemType Directory -Force | Out-Null
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

curlie/README.md

@@ -8,6 +8,16 @@ tagline: |
 To update or switch versions, run `webi curlie@stable` (or `@v1.6`, `@beta`,
 etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/curlie
+```
+
 ## Cheat Sheet
 
 > If you like the interface of HTTPie but miss the features of curl, curlie is

curlie/install.ps1

@@ -3,41 +3,39 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        # Move single binary into root of temporary folder
-        & move "$EXENAME" "$VERNAME"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Move single binary into root of temporary folder
+    & Move-Item "$EXENAME" "$VERNAME"
 
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

dashcore/install.ps1

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

dashd/install.ps1

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

dashmsg/install.ps1

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

delta/install.ps1

@@ -15,51 +15,49 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\delta-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\delta-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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"))
-{
-    echo "Downloading delta from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading delta from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing delta"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing delta"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path ".\delta-v*" -Recurse -ErrorAction Ignore
-        Remove-Item -Path ".\delta.exe" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\delta-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\delta.exe" -Recurse -ErrorAction Ignore
 
-        # Unpack archive file into this temporary directory
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    # 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
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
-        Move-Item -Path ".\delta-*\delta.exe" -Destination "$pkg_src_bin"
+    # 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 ".\delta-*\delta.exe" -Destination "$pkg_src_bin"
 
-        # set delta to be the default differ
-        git config --global page.diff delta
-        git config --global page.show delta
-        git config --global page.log delta
-        git config --global page.blame delta
-        git config --global page.reflog delta
+    # set delta to be the default differ
+    git config --global page.diff delta
+    git config --global page.show delta
+    git config --global page.log delta
+    git config --global page.blame delta
+    git config --global page.reflog delta
 
-        git config --global interactive.diffFilter 'delta --color-only'
+    git config --global interactive.diffFilter 'delta --color-only'
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

deno/install.ps1

@@ -1,40 +1,38 @@
 #!/usr/bin/env pwsh
 
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     #Invoke-WebRequest https://nodejs.org/dist/v12.16.2/node-v12.16.2-win-x64.zip -OutFile node-v12.16.2-win-x64.zip
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter opt
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "deno-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "deno-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-        # Settle unpacked archive into place
-        echo "New Name: $Env:PKG_NAME-v$Env:WEBI_VERSION"
-        Get-ChildItem "deno*" | Select -f 1 | Rename-Item -NewName "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
-        echo "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
-        Move-Item -Path "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe" -Destination "$Env:USERPROFILE\.local\opt"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $Env:PKG_NAME-v$Env:WEBI_VERSION"
+    Get-ChildItem "deno*" | Select-Object -f 1 | Rename-Item -NewName "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
+    Write-Output "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
+    Move-Item -Path "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe" -Destination "$Env:USERPROFILE\.local\opt"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$Env:PKG_NAME.exe' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION.exe'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$Env:PKG_NAME.exe' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION.exe'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$Env:PKG_NAME.exe" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION.exe" -Destination "$Env:USERPROFILE\.local\bin\$Env:PKG_NAME.exe" -Recurse

dotenv-linter/README.md

@@ -5,20 +5,32 @@ tagline: |
   dotenv-linter: ⚡️ Lightning-fast linter for .env files. Written in Rust 🦀
 ---
 
-### Updating `dotenv-linter`
+To update or switch versions, run `webi dotenv-linter@stable` (or `@v3.3`,
+`@beta`, etc).
 
-`webi dotenv-linter@stable`
+### Files
 
-Use the `@beta` tag for pre-releases.
+These are the files / directories that are created and/or modified with this
+install:
 
-#### Windows
+```text
+~/.config/envman/PATH.env
+~/.local/bin/dotenv-linter
+```
 
-On Windows you'll get an error like this:
+**Windows Users**
 
-> execution cannot proceed run because `vcruntime140.dll` was not found
+```text
+\Windows\System32\vcruntime140.dll
+```
 
-You need to download and install the
-[Microsoft Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads).
+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](msvc-learn).
+
+[msvc-learn]:
+  https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170
 
 ## Cheat Sheet
 
@@ -48,14 +60,29 @@ For the complete usage, see the official
 
 ### How to automatically fix errors
 
-Use the `--fix` flag.
+Use the `fix` subcommand.
 
 ```sh
-dotenv-linter --fix
+dotenv-linter fix
 ```
 
-Backup files in the format of `.env_0000000000` will be created by default. You
-can use `--no-backup` to skip this.
+Backup files in the format of `.env_0000000000` will be created by default. \
+You can use `--no-backup` to skip this.
+
+### How to compare keys between environements
+
+Use the `compare` subcommand
+
+```sh
+dotenv-linter compare ./my-dev.env ./my-prod.env
+```
+
+```text
+Comparing my-dev.env
+Comparing my-prod.env
+my-dev.env is missing keys: FOO_API_TOKEN
+my-prod.env is missing keys: BAR_ID, BAR_SECRET
+```
 
 ### How to toggle linter rules
 
@@ -65,18 +92,20 @@ You can turn off certain linter checks with `--skip` options, for example:
 dotenv-linter --skip QuoteCharacter --skip UnorderedKey
 ```
 
-You can see the full list of linter rules with `dotenv-linter --show-checks`:
+You can see the full list of linter rules with `dotenv-linter list`:
 
 ```text
 DuplicatedKey
 EndingBlankLine
 ExtraBlankLine
 IncorrectDelimiter
-LeadingCharacter
 KeyWithoutValue
+LeadingCharacter
 LowercaseKey
 QuoteCharacter
 SpaceCharacter
+SubstitutionKey
 TrailingWhitespace
 UnorderedKey
+ValueWithoutQuotes
 ```

dotenv-linter/install.ps1

@@ -15,43 +15,47 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\dotenv-linter-v$Env:WEBI_VERSION\bin
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\dotenv-linter-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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"))
-{
-    echo "Downloading dotenv-linter from $Env:WEBI_PKG_URL to $pkg_download"
-    & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+# Fetch MSVC Runtime
+Write-Output "Checking for MSVC Runtime..."
+IF (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
+    & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing dotenv-linter"
+# Fetch archive
+IF (!(Test-Path -Path "$pkg_download")) {
+    Write-Output "Downloading dotenv-linter from $Env:WEBI_PKG_URL to $pkg_download"
+    & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
+    & Move-Item "$pkg_download.part" "$pkg_download"
+}
+
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing dotenv-linter"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path ".\dotenv-linter-v*" -Recurse -ErrorAction Ignore
-        Remove-Item -Path ".\dotenv-linter.exe" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\dotenv-linter-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\dotenv-linter.exe" -Recurse -ErrorAction Ignore
 
-        # Unpack archive file into this temporary directory
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    # 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
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
-        Move-Item -Path ".\dotenv-linter.exe" -Destination "$pkg_src_bin"
+    # 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 ".\dotenv-linter.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

dotenv/README.md

@@ -7,6 +7,16 @@ tagline: |
 
 To update or switch versions, run `webi dotenv@stable`.
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/dotenv
+```
+
 ## Cheat Sheet
 
 > dotenv makes it easy to run a command with a set of ENVs (environment

dotenv/install.ps1

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

fd/README.md

@@ -7,6 +7,17 @@ tagline: |
 
 To update or switch versions, run `webi fd@stable` (or `@v8.2`, `@beta`, etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.config/fd/ignore
+~/.local/bin/fd
+```
+
 ## Cheat Sheet
 
 ![](https://github.com/sharkdp/fd/raw/master/doc/screencast.svg?sanitize=true)

fd/install.ps1

@@ -3,41 +3,39 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        # Move single binary into root of temporary folder
-        & move "$EXENAME" "$VERNAME"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Move single binary into root of temporary folder
+    & Move-Item "$EXENAME" "$VERNAME"
 
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

ffmpeg/README.md

@@ -8,6 +8,16 @@ tagline: |
 To update or switch versions, run `webi ffmpeg@stable` (or `@v4.4`, `@beta`,
 etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/ffmpeg
+```
+
 ## Cheat Sheet
 
 > FFmpeg is useful for converting between various audio, video, and image

ffmpeg/install.ps1

@@ -15,37 +15,35 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\ffmpeg-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\ffmpeg-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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"))
-{
-    echo "Downloading ffmpeg from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading ffmpeg from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
     Move-Item -Path "$pkg_download.part" -Destination "$pkg_download" -Force
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing ffmpeg"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing ffmpeg"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path ".\win32-*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\win32-*" -Recurse -ErrorAction Ignore
 
-        # Settle unpacked archive into place
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
-        Move-Item -Path "$pkg_download" -Destination "$pkg_src_cmd" -Force
+    # 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 "$pkg_download" -Destination "$pkg_src_cmd" -Force
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

ffuf/README.md

@@ -0,0 +1,118 @@
+---
+title: ffuf
+homepage: https://github.com/ffuf/ffuf
+tagline: |
+  Fuzz Faster U Fool: A fast web fuzzer written in Go.
+---
+
+To update or switch versions, run `webi ffuf@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/ffuf
+```
+
+## Cheat Sheet
+
+> `ffuf` is a powerful web fuzzer written in Go. With a range of functionalities
+> and fast performance, it's a must-have tool for penetration testers and
+> security researchers.
+
+[![ffuf mascot](https://github.com/ffuf/ffuf/blob/v2.1.0/_img/ffuf_run_logo_600.png?raw=true)](https://github.com/ffuf/ffuf)
+
+Rotate through wordlists to discover and report exposed URLs, domains, etc.
+
+```sh
+# fuff -w <list>[:VAR] -u 'https://<target>/<VAR>'
+fuff -w ./fuzz-Bo0oM.txt -u 'https://ffuf.io.fi/FUZZ
+```
+
+```sh
+fuff \
+    -w ./fuzz-Bo0oM.txt:'FUZZ_PATH' \
+    -w ./subdomains-top1million-5000.txt:'FUZZ_SUB' \
+    -u  'https://FUZZ_SUB.ffuf.io.fi/FUZZ_PATH'
+```
+
+### How to get ffuf wordlists
+
+| Download                                 | &emsp; Source                          | &emsp; Desc                |
+| ---------------------------------------- | -------------------------------------- | -------------------------- |
+| [onelistforallmicro.txt][4allu]          | &emsp; [OneListForAll][4all]           | &emsp; Words, Paths, Files |
+| [fuzz-Bo0oM.txt][boom]                   | &emsp; [SecLists/Fuzzing][fuzz]        | &emsp; Words, Paths, Files |
+| [subdomains-top1million-5000.txt][sub5k] | &emsp; [SecLists/.../DNS][dns]         | &emsp; Common Subdomains   |
+| [burp-parameter-names.txt][params]       | &emsp; [SecLists/.../Web-Content][web] | &emsp; HTTP Query Params   |
+| [urls-wordpress-3.3.1.txt][wp3]          | &emsp; [SecLists/.../URLs][urls]       | &emsp; WordPress v3 Paths  |
+
+<!-- Browse Categories -->
+
+[4all]: https://github.com/six2dez/OneListForAll/
+[dns]: https://github.com/danielmiessler/SecLists/blob/master/Discovery/DNS/
+[fuzz]: https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/
+[web]:
+  https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/
+[seclist]: https://github.com/danielmiessler/SecLists/
+[urls]:
+  https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/
+
+<!-- Download Lists -->
+
+[4allu]:
+  https://raw.githubusercontent.com/six2dez/OneListForAll/main/onelistforallmicro.txt
+[boom]:
+  https://raw.githubusercontent.com/danielmiessler/SecLists/master/Fuzzing/fuzz-Bo0oM.txt
+[params]:
+  https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/burp-parameter-names.txt
+[sub5k]:
+  https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/DNS/subdomains-top1million-5000.txt
+[wp3]:
+  https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/URLs/urls-wordpress-3.3.1.txt
+
+<br>
+
+These were pulled from the resources mentioned in
+[ffuf wiki: Wordlistt Resources](https://github.com/ffuf/ffuf/wiki#wordlist-resources):
+
+- [six2dez/OneListForAll][4all]
+- [danielmiessler/SecLists][seclist]
+
+### How to Discover Exposed Content
+
+For typical directory discovery:
+
+```sh
+ffuf -w ./onelistforallmicro.txt:'FUZZ' -u https://example.com/FUZZ
+```
+
+### How to check for Domain Fronting (VHost Discovery)
+
+Assuming a default virtualhost response size:
+
+```sh
+ffuf \
+    -w ./subdomains-top1million-5000.txt:'SUB' \
+    -u https://example.com \
+    -H "Host: SUB.example.com" \
+    -fs 4242
+```
+
+### How to Fuzz GET Parameters
+
+For fuzzing GET parameter names:
+
+```sh
+ffuf \
+    -w ./burp-parameter-names.txt:'KEY' \
+    -u https://example.com/script.php?KEY=test_value \
+    -fs 4242
+```
+
+### More Resources
+
+See [ffuf wiki](https://github.com/ffuf/ffuf/wiki):
+<https://github.com/ffuf/ffuf/wiki>.

ffuf/install.ps1

@@ -0,0 +1,61 @@
+#!/usr/bin/env pwsh
+
+##################
+# Install ffuf #
+##################
+
+# Every package should define these variables
+$pkg_cmd_name = "ffuf"
+
+$pkg_dst_cmd = "$Env:USERPROFILE\.local\bin\ffuf.exe"
+$pkg_dst_bin = "$Env:USERPROFILE\.local\bin\"
+$pkg_dst = "$pkg_dst_cmd"
+
+$pkg_src_cmd = "$Env:USERPROFILE\.local\opt\ffuf-v$Env:WEBI_VERSION\bin\ffuf.exe"
+$pkg_src_bin = "$Env:USERPROFILE\.local\opt\ffuf-v$Env:WEBI_VERSION\bin"
+$pkg_src_dir = "$Env:USERPROFILE\.local\opt\ffuf-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 (-Not (Test-Path -Path "$pkg_download")) {
+    Write-Output "Downloading ffuf from $Env:WEBI_PKG_URL to $pkg_download"
+    & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
+    & Move-Item "$pkg_download.part" "$pkg_download"
+}
+
+IF (-Not (Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing ffuf"
+
+    # TODO: create package-specific temp directory
+    # Enter tmp
+    Push-Location .local\tmp
+
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\ffuf-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\ffuf.exe" -Recurse -ErrorAction Ignore
+
+    # NOTE: DELETE THIS COMMENT IF NOT USED
+    # Move single binary into root of temporary folder
+    #& move "$pkg_download" "ffuf.exe"
+
+    # 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 ".\ffuf.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

ffuf/install.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# shellcheck disable=SC2034
+# "'pkg_cmd_name' appears unused. Verify it or export it."
+
+__init_ffuf() {
+    set -e
+    set -u
+
+    ################
+    # Install ffuf #
+    ################
+
+    # Every package should define these 6 variables
+    pkg_cmd_name="ffuf"
+
+    pkg_dst_cmd="$HOME/.local/bin/ffuf"
+    pkg_dst="$pkg_dst_cmd"
+
+    pkg_src_cmd="$HOME/.local/opt/ffuf-v$WEBI_VERSION/bin/ffuf"
+    pkg_src_dir="$HOME/.local/opt/ffuf-v$WEBI_VERSION"
+    pkg_src="$pkg_src_cmd"
+
+    # pkg_install must be defined by every package
+    pkg_install() {
+        # ~/.local/opt/ffuf-v2.1.0/bin
+        mkdir -p "$(dirname "${pkg_src_cmd}")"
+
+        # mv ./ffuf-*/ffuf ~/.local/opt/ffuf-v2.1.0/bin/ffuf
+        mv ./ffuf "$pkg_src_cmd"
+    }
+
+    # pkg_get_current_version is recommended, but not required
+    pkg_get_current_version() {
+        # 'ffuf -V' has output in this format:
+        #       ffuf version: 2.1.0
+        # This trims it down to just the version number:
+        #       2.1.0
+        ffuf -V 2> /dev/null |
+            head -n 1 |
+            cut -d' ' -f3
+    }
+
+}
+
+__init_ffuf

ffuf/releases.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var github = require('../_common/github.js');
+var owner = 'ffuf';
+var repo = 'ffuf';
+
+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));
+  });
+}

flutter/README.md

@@ -8,6 +8,17 @@ tagline: |
 To update or switch versions, run `webi flutter@stable` (or `@v2.2`, `@beta`,
 etc).
 
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/opt/flutter
+<PROJECT-DIR>/pubspec.yaml
+```
+
 ## Cheat Sheet
 
 > Flutter is Google’s UI toolkit for building beautiful, natively compiled

fzf/README.md

@@ -7,6 +7,13 @@ tagline: |
 
 To update or switch versions, run `webi fzf@stable` (or `@v0.23`, `@beta`, etc).
 
+### Files
+
+```text
+~/.config/envman/PATH.env
+~/.local/bin/fzf
+```
+
 ## Cheat Sheet
 
 ![](https://raw.githubusercontent.com/junegunn/i/master/fzf-preview.png)

fzf/install.ps1

@@ -3,41 +3,39 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        # Move single binary into root of temporary folder
-        & move "$EXENAME" "$VERNAME"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Move single binary into root of temporary folder
+    & Move-Item "$EXENAME" "$VERNAME"
 
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

gh/install.ps1

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

git-gpg-init/install.ps1

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

git/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
 $pkg_cmd_name = "git"
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 $pkg_src = "$Env:USERPROFILE\.local\opt\$pkg_cmd_name-v$Env:WEBI_VERSION"
@@ -11,44 +11,42 @@ $pkg_dst_cmd = "$pkg_dst\cmd\$pkg_cmd_name"
 $pkg_dst_bin = "$pkg_dst\cmd"
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$pkg_download")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src"))
-{
-    echo "Installing $pkg_cmd_name"
+IF (!(Test-Path -Path "$pkg_src")) {
+    Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
     # Enter opt
-    ($none = pushd .local\tmp) | out-null
+    ($none = Push-Location .local\tmp) | Out-Null
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $pkg_download"
-        IF (!(Test-Path -Path "$pkg_cmd_name-v$Env:WEBI_VERSION")) {
-            New-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -ItemType Directory -Force | out-null
-        }
-        ($none = pushd "$pkg_cmd_name-v$Env:WEBI_VERSION")  | out-null
-            & tar xf "$pkg_download"
-        ($none = popd)  | out-null
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $pkg_download"
+    IF (!(Test-Path -Path "$pkg_cmd_name-v$Env:WEBI_VERSION")) {
+        New-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -ItemType Directory -Force | Out-Null
+    }
+        ($none = Push-Location "$pkg_cmd_name-v$Env:WEBI_VERSION")  | Out-Null
+    & tar xf "$pkg_download"
+        ($none = Pop-Location)  | Out-Null
 
-        # Settle unpacked archive into place
-        echo "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
-        echo "New Location: $pkg_src"
-        Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
+    Write-Output "New Location: $pkg_src"
+    Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
 
     # Exit tmp
-    $none = popd
+    $none = Pop-Location
 }
 
-echo "Copying into '$pkg_dst' from '$pkg_src'"
+Write-Output "Copying into '$pkg_dst' from '$pkg_src'"
 Remove-Item -Path "$pkg_dst" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
 

gitdeploy/install.ps1

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

gitea/install.ps1

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

go-essentials/install.ps1

@@ -1,29 +1,28 @@
 #!/usr/bin/env pwsh
 
-if (!(Get-Command "go.exe" -ErrorAction SilentlyContinue))
-{
+if (!(Get-Command "go.exe" -ErrorAction SilentlyContinue)) {
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" go
     # because we need git.exe to be available to golang immediately
     $Env:PATH = "$Env:USERPROFILE\go\bin;$Env:USERPROFILE\.local\opt\go\bin;$Env:PATH"
 }
 
 # Special to go: re-run all go tooling builds
-echo "Building go language tools..."
+Write-Output "Building go language tools..."
 
-echo ""
-echo godoc
+Write-Output ""
+Write-Output godoc
 & go install golang.org/x/tools/cmd/godoc@latest
 
-echo ""
-echo gopls
+Write-Output ""
+Write-Output gopls
 & go install golang.org/x/tools/gopls@latest
 
-echo ""
-echo guru
+Write-Output ""
+Write-Output guru
 & go install golang.org/x/tools/guru@latest
 
-echo ""
-echo golint
+Write-Output ""
+Write-Output golint
 & go install golang.org/x/lint/golint@latest
 
 #echo ""
@@ -34,33 +33,33 @@ echo golint
 #echo gotags
 #& go install github.com/jstemmer/gotags
 
-echo ""
-echo goimports
+Write-Output ""
+Write-Output goimports
 & go install golang.org/x/tools/cmd/goimports@latest
 
-echo ""
-echo gomvpkg
+Write-Output ""
+Write-Output gomvpkg
 & go install golang.org/x/tools/cmd/gomvpkg@latest
 
-echo ""
-echo gorename
+Write-Output ""
+Write-Output gorename
 & go install golang.org/x/tools/cmd/gorename
 
-echo ""
-echo gotype
+Write-Output ""
+Write-Output gotype
 & go install golang.org/x/tools/cmd/gotype
 
-echo ""
-echo stringer
+Write-Output ""
+Write-Output stringer
 & go install golang.org/x/tools/cmd/stringer
 
-echo ""
+Write-Output ""
 # literal %USERPROFILE% on purpose
-echo 'Installed go "x" tools to GOBIN=%USERPROFILE%/go/bin'
+Write-Output 'Installed go "x" tools to GOBIN=%USERPROFILE%/go/bin'
 
-echo ""
-echo "Suggestion: Also check out these great productivity multipliers:"
-echo ""
-echo "    - vim-essentials  (sensible defaults for vim)"
-echo "    - vim-go          (golang linting, etc)"
-echo ""
+Write-Output ""
+Write-Output "Suggestion: Also check out these great productivity multipliers:"
+Write-Output ""
+Write-Output "    - vim-essentials  (sensible defaults for vim)"
+Write-Output "    - vim-go          (golang linting, etc)"
+Write-Output ""

go/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
 $pkg_cmd_name = "go"
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 $pkg_src = "$Env:USERPROFILE\.local\opt\$pkg_cmd_name-v$Env:WEBI_VERSION"
@@ -10,51 +10,48 @@ $pkg_dst = "$Env:USERPROFILE\.local\opt\$pkg_cmd_name"
 $pkg_dst_cmd = "$pkg_dst\bin\$pkg_cmd_name"
 $pkg_dst_bin = "$pkg_dst\bin"
 
-if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue))
-{
+if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" git
     # because we need git.exe to be available to golang immediately
     $Env:PATH = "$Env:USERPROFILE\.local\opt\git\cmd;$Env:PATH"
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$pkg_download")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src"))
-{
-    echo "Installing $pkg_cmd_name"
+IF (!(Test-Path -Path "$pkg_src")) {
+    Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
     # Enter opt
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
 
-        # Settle unpacked archive into place
-        echo "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
-        Get-ChildItem "$pkg_cmd_name*" | Select -f 1 | Rename-Item -NewName "$pkg_cmd_name-v$Env:WEBI_VERSION"
-        echo "New Location: $pkg_src"
-        Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
+    Get-ChildItem "$pkg_cmd_name*" | Select-Object -f 1 | Rename-Item -NewName "$pkg_cmd_name-v$Env:WEBI_VERSION"
+    Write-Output "New Location: $pkg_src"
+    Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst' from '$pkg_src'"
+Write-Output "Copying into '$pkg_dst' from '$pkg_src'"
 Remove-Item -Path "$pkg_dst" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
-IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | out-null }
+IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
 
 # Add to path
 webi_path_add ~/.local/opt/go/bin

golang/install.ps1

@@ -1,7 +1,7 @@
 #!/usr/bin/env pwsh
 
 $pkg_cmd_name = "go"
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
 $pkg_src = "$Env:USERPROFILE\.local\opt\$pkg_cmd_name-v$Env:WEBI_VERSION"
@@ -10,51 +10,48 @@ $pkg_dst = "$Env:USERPROFILE\.local\opt\$pkg_cmd_name"
 $pkg_dst_cmd = "$pkg_dst\bin\$pkg_cmd_name"
 $pkg_dst_bin = "$pkg_dst\bin"
 
-if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue))
-{
+if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
     & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" git
     # because we need git.exe to be available to golang immediately
     $Env:PATH = "$Env:USERPROFILE\.local\opt\git\cmd;$Env:PATH"
 }
 
 # Fetch archive
-IF (!(Test-Path -Path "$pkg_download"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$pkg_download")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src"))
-{
-    echo "Installing $pkg_cmd_name"
+IF (!(Test-Path -Path "$pkg_src")) {
+    Write-Output "Installing $pkg_cmd_name"
     # TODO: temp directory
 
     # Enter opt
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$pkg_cmd_name*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
 
-        # Settle unpacked archive into place
-        echo "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
-        Get-ChildItem "$pkg_cmd_name*" | Select -f 1 | Rename-Item -NewName "$pkg_cmd_name-v$Env:WEBI_VERSION"
-        echo "New Location: $pkg_src"
-        Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $pkg_cmd_name-v$Env:WEBI_VERSION"
+    Get-ChildItem "$pkg_cmd_name*" | Select-Object -f 1 | Rename-Item -NewName "$pkg_cmd_name-v$Env:WEBI_VERSION"
+    Write-Output "New Location: $pkg_src"
+    Move-Item -Path "$pkg_cmd_name-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst' from '$pkg_src'"
+Write-Output "Copying into '$pkg_dst' from '$pkg_src'"
 Remove-Item -Path "$pkg_dst" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
-IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | out-null }
+IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Force | Out-Null }
 
 # Add to path
 webi_path_add ~/.local/opt/go/bin

goreleaser/install.ps1

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

gpg-pubkey/gpg-pubkey.ps1

@@ -7,13 +7,12 @@ $my_key_id = gpg --list-secret-keys --keyid-format LONG |
         $_.Line.split('/')[1].split(' ')[0]
     }
 
-if (!$my_key_id)
-{
+if (!$my_key_id) {
     $my_name = git config --global user.name
     $my_email = git config --global user.email
     $my_host = hostname
 
-    echo "
+    Write-Output "
      %echo Generating RSA 3072 key
      Key-Type: RSA
      Key-Length: 3072
@@ -32,10 +31,10 @@ $my_asc_relpath = "Downloads/$my_email.$my_key_id.gpg.asc"
 
 # TODO use the comment (if any) for the name of the file
 $my_email = git config --global user.email
-echo ""
-echo "GnuPG Public Key ID: $MY_KEY_ID"
-echo ""
-echo "~/$my_asc_relpath":
-echo ""
-& type "$Env:USERPROFILE/$my_asc_relpath"
-echo ""
+Write-Output ""
+Write-Output "GnuPG Public Key ID: $MY_KEY_ID"
+Write-Output ""
+Write-Output "~/$my_asc_relpath":
+Write-Output ""
+& Get-Content "$Env:USERPROFILE/$my_asc_relpath"
+Write-Output ""

gpg-pubkey/install.ps1

@@ -8,7 +8,7 @@ $MY_SUBCMD = "gpg-pubkey-id"
 
 & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_HOST/packages/$MY_CMD/$MY_SUBCMD.ps1" -o "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1.part"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1" -Recurse -ErrorAction Ignore
-& move "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1.part" "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1"
+& Move-Item "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1.part" "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.ps1"
 Set-Content -Path "$Env:USERPROFILE\.local\bin\$MY_SUBCMD.bat" -Value "@echo off`r`npushd %USERPROFILE%`r`npowershell -ExecutionPolicy Bypass .local\bin\$MY_SUBCMD.ps1 %1`r`npopd"
 
 #
@@ -18,7 +18,7 @@ $MY_CMD = "gpg-pubkey"
 
 & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_HOST/packages/$MY_CMD/$MY_CMD.ps1" -o "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1.part"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1" -Recurse -ErrorAction Ignore
-& move "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1.part" "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1"
+& Move-Item "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1.part" "$Env:USERPROFILE\.local\bin\$MY_CMD.ps1"
 Set-Content -Path "$Env:USERPROFILE\.local\bin\$MY_CMD.bat" -Value "@echo off`r`npushd %USERPROFILE%`r`npowershell -ExecutionPolicy Bypass .local\bin\$MY_CMD.ps1 %1`r`npopd"
 
 #
@@ -30,9 +30,9 @@ if (!$gpg_exists) {
     curl.exe "$Env:WEBI_HOST/gpg" | powershell
     $gpg_exists = Get-Command gpg 2> $null
     if (!$gpg_exists) {
-        echo ""
-        echo "(exited because gpg is not existalled)"
-        echo ""
+        Write-Output ""
+        Write-Output "(exited because gpg is not existalled)"
+        Write-Output ""
         Exit 1
     }
 }

gpg/install.ps1

@@ -1,6 +1,6 @@
 #!/usr/bin/env pwsh
 
-echo "We don't yet have a way to automate the GnuPG Tools installer at the user level. In the meantime, try this:"
-echo ""
-echo "    https://gnupg.org/download/#binary"
-echo ""
+Write-Output "We don't yet have a way to automate the GnuPG Tools installer at the user level. In the meantime, try this:"
+Write-Output ""
+Write-Output "    https://gnupg.org/download/#binary"
+Write-Output ""

gprox/install.ps1

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

grype/README.md

@@ -0,0 +1,45 @@
+---
+title: Grype
+homepage: https://github.com/anchore/grype/
+tagline: |
+  Grype is a vulnerability scanner for container images and filesystems.
+---
+
+To update or switch versions, run `webi grype@stable` (or `@v0.6`, `@beta`, etc)
+
+### Files
+
+```text
+~/.config/envman/PATH.env
+~/.grype.yaml
+~/.local/bin/grype
+```
+
+## Cheat Sheet
+
+> It also helps find vulnerabilities for major operating system and
+> language-specific packages. Supports Docker, OCI and Singularity image
+> formats, OpenVEX support for filtering and augmenting scanning results. Works
+> with `syft`, a powerful `SBOM` (software bill of materials) tool for container
+> images and file systems
+
+### How to for vulnerabilities in an image
+
+```sh
+grype <image>
+```
+
+### How to scan all image layers
+
+```sh
+grype <image> --scope all-layers
+```
+
+### How to scan a running container
+
+```sh
+docker run --rm \
+    --volume /var/run/docker.sock:/var/run/docker.sock \
+    --name Grype anchore/grype:latest \
+    my_image_name:my_image_tag
+```

grype/install.ps1

@@ -0,0 +1,57 @@
+#!/usr/bin/env pwsh
+
+#################
+# Install grype #
+#################
+
+# Every package should define these variables
+$pkg_cmd_name = "grype"
+
+$pkg_dst_cmd = "$Env:USERPROFILE\.local\bin\grype.exe"
+$pkg_dst_bin = "$Env:USERPROFILE\.local\bin"
+$pkg_dst = "$pkg_dst_cmd"
+
+$pkg_src_cmd = "$Env:USERPROFILE\.local\opt\grype-v$Env:WEBI_VERSION\bin\grype.exe"
+$pkg_src_bin = "$Env:USERPROFILE\.local\opt\grype-v$Env:WEBI_VERSION\bin"
+$pkg_src_dir = "$Env:USERPROFILE\.local\opt\grype-v$Env:WEBI_VERSION"
+$pkg_src = "$pkg_src_cmd"
+
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
+$pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+
+# Fetch archive
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading grype from $Env:WEBI_PKG_URL to $pkg_download"
+    & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
+    & Move-Item "$pkg_download.part" "$pkg_download"
+}
+
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing grype"
+
+    # TODO: create package-specific temp directory
+    # Enter tmp
+    Push-Location .local\tmp
+
+    # Remove any leftover tmp cruft
+    Remove-Item -Path ".\grype-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\grype.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 ".\grype.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

grype/install.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+set -e
+set -u
+
+__init_grype() {
+
+    ##################
+    # Install Grype  #
+    ##################
+
+    # Every package should define these 6 variables
+    pkg_cmd_name="grype"
+
+    pkg_dst_cmd="$HOME/.local/bin/grype"
+    pkg_dst="$pkg_dst_cmd"
+
+    pkg_src_cmd="$HOME/.local/opt/grype-v$WEBI_VERSION/bin/grype"
+    pkg_src_dir="$HOME/.local/opt/grype-v$WEBI_VERSION"
+    pkg_src="$pkg_src_cmd"
+
+    # pkg_install must be defined by every package
+    pkg_install() {
+        # ~/.local/opt/grype-v0.99.9/bin
+        mkdir -p "$(dirname "${pkg_src_cmd}")"
+
+        # mv ./grype ~/.local/opt/grype-v0.99.9/bin/grype
+        mv ./"$pkg_cmd_name"* "$pkg_src"
+    }
+
+    # pkg_get_current_version is recommended, but not required
+    pkg_get_current_version() {
+        # 'grype --version' has output in this format:
+        #       grype 0.70.0
+        # This trims it down to just the version number:
+        #       0.70.0
+        grype --version 2> /dev/null |
+            head -n 1 |
+            cut -d ' ' -f 2
+    }
+
+}
+
+__init_grype

grype/releases.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var github = require('../_common/github.js');
+var owner = 'anchore';
+var repo = 'grype';
+
+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));
+  });
+}

hugo-extended/install.ps1

@@ -16,22 +16,22 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\hugo-extended-v$Env:WEBI_VERSION\bin
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\hugo-extended-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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")) {
-    echo "Downloading hugo-extended from $Env:WEBI_PKG_URL to $pkg_download"
+    Write-Output "Downloading hugo-extended from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
 IF (!(Test-Path -Path "$pkg_src_cmd")) {
-    echo "Installing hugo-extended"
+    Write-Output "Installing hugo-extended"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
     # Remove any leftover tmp cruft
     Remove-Item -Path ".\hugo-extended-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.
-    echo "Unpacking $pkg_download"
+    Write-Output "Unpacking $pkg_download"
     & tar xf "$pkg_download"
 
     # Settle unpacked archive into place
-    echo "Install Location: $pkg_src_cmd"
-    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
     Move-Item -Path ".\hugo.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-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
+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

hugo/install.ps1

@@ -16,22 +16,22 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\hugo-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\hugo-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+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")) {
-    echo "Downloading hugo from $Env:WEBI_PKG_URL to $pkg_download"
+    Write-Output "Downloading hugo from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
 IF (!(Test-Path -Path "$pkg_src_cmd")) {
-    echo "Installing hugo"
+    Write-Output "Installing hugo"
 
     # TODO: create package-specific temp directory
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
     # Remove any leftover tmp cruft
     Remove-Item -Path ".\hugo-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.
-    echo "Unpacking $pkg_download"
+    Write-Output "Unpacking $pkg_download"
     & tar xf "$pkg_download"
 
     # Settle unpacked archive into place
-    echo "Install Location: $pkg_src_cmd"
-    New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
     Move-Item -Path ".\hugo.exe" -Destination "$pkg_src_bin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-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
+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

jq/install.ps1

@@ -3,38 +3,36 @@
 $VERNAME = "$Env:PKG_NAME-v$Env:WEBI_VERSION.exe"
 $EXENAME = "$Env:PKG_NAME.exe"
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\xbin\$VERNAME")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter tmp
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "$Env:PKG_NAME-v*" -Recurse -ErrorAction Ignore
 
-        # Move single binary into temporary folder
-        echo "Moving $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "$VERNAME"
+    # Move single binary into temporary folder
+    Write-Output "Moving $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "$VERNAME"
 
-        # Settle unpacked archive into place
-        echo "New Name: $VERNAME"
-        Get-ChildItem "$Env:PKG_NAME-v*" | Select -f 1 | Rename-Item -NewName "$VERNAME"
-        echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
-        Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $VERNAME"
+    Get-ChildItem "$Env:PKG_NAME-v*" | Select-Object -f 1 | Rename-Item -NewName "$VERNAME"
+    Write-Output "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
+    Move-Item -Path "$VERNAME" -Destination "$Env:USERPROFILE\.local\xbin"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\bin\$EXENAME' from '$Env:USERPROFILE\.local\xbin\$VERNAME'"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

k9s/install.ps1

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

keypairs/install.ps1

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

kind/install.ps1

@@ -14,34 +14,32 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\kind-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\kind-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading kind from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading kind from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing kind"
-    pushd .local\tmp
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing kind"
+    Push-Location .local\tmp
 
-        Remove-Item -Path ".\kind-v*" -Recurse -ErrorAction Ignore
-        Remove-Item -Path ".\kind.exe" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\kind-v*" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\kind.exe" -Recurse -ErrorAction Ignore
 
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
 
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force
-        Move-Item -Path ".\kind-*\kind.exe" -Destination "$pkg_src_bin"
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force
+    Move-Item -Path ".\kind-*\kind.exe" -Destination "$pkg_src_bin"
 
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
 Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

kubectx/install.ps1

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

kubens/install.ps1

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

lf/install.ps1

@@ -14,34 +14,32 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\lf-v$Env:WEBI_VERSION\bin"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\lf-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading lf from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading lf from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing lf"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing lf"
 
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        Remove-Item -Path ".\lf.exe" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\lf.exe" -Recurse -ErrorAction Ignore
 
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
 
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_bin" -ItemType Directory -Force | out-null
-        Move-Item -Path ".\lf.exe" -Destination "$pkg_src_bin"
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
+    Move-Item -Path ".\lf.exe" -Destination "$pkg_src_bin"
 
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

lsd/install.ps1

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

mutagen/install.ps1

@@ -14,34 +14,32 @@ $pkg_src_bin = "$Env:USERPROFILE\.local\opt\mutagen-v$Env:WEBI_VERSION"
 $pkg_src_dir = "$Env:USERPROFILE\.local\opt\mutagen-v$Env:WEBI_VERSION"
 $pkg_src = "$pkg_src_cmd"
 
-New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
 $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading mutagen from $Env:WEBI_PKG_URL to $pkg_download"
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading mutagen from $Env:WEBI_PKG_URL to $pkg_download"
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
-    & move "$pkg_download.part" "$pkg_download"
+    & Move-Item "$pkg_download.part" "$pkg_download"
 }
 
-IF (!(Test-Path -Path "$pkg_src_cmd"))
-{
-    echo "Installing mutagen"
+IF (!(Test-Path -Path "$pkg_src_cmd")) {
+    Write-Output "Installing mutagen"
 
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        Remove-Item -Path ".\mutagen.exe" -Recurse -ErrorAction Ignore
+    Remove-Item -Path ".\mutagen.exe" -Recurse -ErrorAction Ignore
 
-        echo "Unpacking $pkg_download"
-        & tar xf "$pkg_download"
+    Write-Output "Unpacking $pkg_download"
+    & tar xf "$pkg_download"
 
-        echo "Install Location: $pkg_src_cmd"
-        New-Item "$pkg_src_dir" -ItemType Directory -Force | out-null
-        Move-Item -Path ".\*" -Destination "$pkg_src_dir"
+    Write-Output "Install Location: $pkg_src_cmd"
+    New-Item "$pkg_src_dir" -ItemType Directory -Force | Out-Null
+    Move-Item -Path ".\*" -Destination "$pkg_src_dir"
 
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
-Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | out-null
+Write-Output "Copying into '$pkg_dst_cmd' from '$pkg_src_cmd'"
+Remove-Item -Path "$pkg_dst_cmd" -Recurse -ErrorAction Ignore | Out-Null
 Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

myip/install.ps1

@@ -2,6 +2,6 @@
 
 & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_HOST/packages/myip/myip.ps1" -o "$Env:USERPROFILE\.local\bin\myip.ps1.part"
 Remove-Item -Path "$Env:USERPROFILE\.local\bin\myip.ps1" -Recurse -ErrorAction Ignore
-& move "$Env:USERPROFILE\.local\bin\myip.ps1.part" "$Env:USERPROFILE\.local\bin\myip.ps1"
+& Move-Item "$Env:USERPROFILE\.local\bin\myip.ps1.part" "$Env:USERPROFILE\.local\bin\myip.ps1"
 Set-Content -Path "$Env:USERPROFILE\.local\bin\myip.bat" -Value "@echo off`r`npushd %USERPROFILE%`r`npowershell -ExecutionPolicy Bypass .local\bin\myip.ps1 %1`r`npopd"
 & "$Env:USERPROFILE\.local\bin\myip.bat"

myip/myip.ps1

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

nerdfont/install.ps1

@@ -3,20 +3,19 @@
 $my_nerdfont_otf = "Droid Sans Mono for Powerline Nerd Font Complete Windows Compatible.otf"
 $my_fontdir = "$Env:UserProfile\AppData\Local\Microsoft\Windows\Fonts"
 
-New-Item -Path "$my_fontdir" -ItemType Directory -Force | out-null
-IF (!(Test-Path -Path "$my_fontdir\$my_nerdfont_otf"))
-{
+New-Item -Path "$my_fontdir" -ItemType Directory -Force | Out-Null
+IF (!(Test-Path -Path "$my_fontdir\$my_nerdfont_otf")) {
     & curl.exe -fsSLo "$my_nerdfont_otf" 'https://github.com/ryanoasis/nerd-fonts/raw/v2.3.3/patched-fonts/DroidSansMono/complete/Droid%20Sans%20Mono%20Nerd%20Font%20Complete%20Windows%20Compatible.otf'
-    & move "$my_nerdfont_otf" "$my_fontdir"
+    & Move-Item "$my_nerdfont_otf" "$my_fontdir"
 }
 
 
-pushd "$my_fontdir"
+Push-Location "$my_fontdir"
 
 $regFontPath = "\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
 $fontRegistryPath = "HKCU:$regFontPath"
 $fontFiles = Get-ChildItem -Recurse -Include *.ttf, *.otf
-foreach($font in $fontFiles) {
+foreach ($font in $fontFiles) {
     # See https://github.com/PPOSHGROUP/PPoShTools/blob/master/PPoShTools/Public/FileSystem/Add-Font.ps1#L80
     Add-Type -AssemblyName System.Drawing
     $objFontCollection = New-Object System.Drawing.Text.PrivateFontCollection
@@ -28,9 +27,9 @@ foreach($font in $fontFiles) {
         New-ItemProperty -Name $FontName -Path $fontRegistryPath -PropertyType string -Value $font.Name
         Write-Output "Registered font {$($font.Name)} in Current User registry as {$FontName}"
     }
-    echo "Installed $my_nerdfont_otf to $my_fontdir"
+    Write-Output "Installed $my_nerdfont_otf to $my_fontdir"
     # because adding to the registry alone doesn't actually take
     & start $font.FullName
-    echo ""
-    echo "IMPORTANT: Click 'Install' to complete installation"
+    Write-Output ""
+    Write-Output "IMPORTANT: Click 'Install' to complete installation"
 }

node/install.ps1

@@ -1,42 +1,40 @@
 #!/usr/bin/env pwsh
 
 # Fetch archive
-IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"))
-{
-    echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-    New-Item -Path "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | out-null
+IF (!(Test-Path -Path "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE")) {
+    Write-Output "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    New-Item -Path "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
     #Invoke-WebRequest https://nodejs.org/dist/v12.16.2/node-v12.16.2-win-x64.zip -OutFile node-v12.16.2-win-x64.zip
     & curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part"
-    & move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE.part" "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 }
 
-IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION"))
-{
-    echo "Installing $Env:PKG_NAME"
+IF (!(Test-Path -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION")) {
+    Write-Output "Installing $Env:PKG_NAME"
     # TODO: temp directory
 
     # Enter opt
-    pushd .local\tmp
+    Push-Location .local\tmp
 
-        # Remove any leftover tmp cruft
-        Remove-Item -Path "node-v*" -Recurse -ErrorAction Ignore
+    # Remove any leftover tmp cruft
+    Remove-Item -Path "node-v*" -Recurse -ErrorAction Ignore
 
-        # Unpack archive
-        # Windows BSD-tar handles zip. Imagine that.
-        echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
-        & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    # Unpack archive
+    # Windows BSD-tar handles zip. Imagine that.
+    Write-Output "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
+    & tar xf "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
 
-        # Settle unpacked archive into place
-        echo "New Name: $Env:PKG_NAME-v$Env:WEBI_VERSION"
-        Get-ChildItem "node-v*" | Select -f 1 | Rename-Item -NewName "$Env:PKG_NAME-v$Env:WEBI_VERSION"
-        echo "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION"
-        Move-Item -Path "$Env:PKG_NAME-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
+    # Settle unpacked archive into place
+    Write-Output "New Name: $Env:PKG_NAME-v$Env:WEBI_VERSION"
+    Get-ChildItem "node-v*" | Select-Object -f 1 | Rename-Item -NewName "$Env:PKG_NAME-v$Env:WEBI_VERSION"
+    Write-Output "New Location: $Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION"
+    Move-Item -Path "$Env:PKG_NAME-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt"
 
     # Exit tmp
-    popd
+    Pop-Location
 }
 
-echo "Copying into '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION'"
+Write-Output "Copying into '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME' from '$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION'"
 Remove-Item -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME" -Recurse -ErrorAction Ignore
 Copy-Item -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION" -Destination "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME" -Recurse
 

ots/install.ps1

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

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@webinstall/webi-installers",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@webinstall/webi-installers",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "license": "MPL-2.0",
       "dependencies": {
         "@root/request": "^1.9.2",

package.json

@@ -5,14 +5,19 @@
   "description": "webinstall script repository",
   "main": "_webi/",
   "scripts": {
-    "fmt": "npm run prettier && npm run shfmt",
-    "lint": "npm run shellcheck && npm run jshint",
+    "fmt": "npm run prettier && npm run shfmt && npm run pwsh-fmt",
+    "lint": "npm run shellcheck && npm run jshint && npm run pwsh-lint",
+    "prepare": "npm run tooling-init && npm run git-hooks-init",
     "test": "node _webi/test.js ./node/",
     "----": "------------------------------------",
+    "git-hooks-init": "node ./_scripts/git-hooks-init.js",
     "jshint": "npx -p jshint@2.x -- jshint -c ./.jshintrc --exclude 'node_modules/**/*' */*.js */*/*.js",
     "prettier": "npx -p prettier@3.x -- prettier -w '**/*.{js,md,html}'",
+    "pwsh-fmt": "pwsh ./_scripts/pwsh-fmt.ps1",
+    "pwsh-lint": "pwsh ./_scripts/pwsh-lint.ps1",
     "shellcheck": "shellcheck -s sh -S style --exclude=SC2154,SC2034 */*.sh",
-    "shfmt": "shfmt -w -i 4 -sr -ci -s ./"
+    "shfmt": "shfmt -w -i 4 -sr -ci -s ./",
+    "tooling-init": "node ./_scripts/tooling-init.js"
   },
   "repository": {
     "type": "git",

pandoc/install.ps1

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

pathman/install.ps1

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

powershell/README.md

@@ -5,6 +5,21 @@ tagline: |
   PowerShell Core is a cross-platform (Windows, Linux, and macOS) automation and configuration tool/framework.
 ---
 
+To update or switch versions, run `webi pwsh@stable` (or `@v7.4`, `@beta`, etc).
+
+### Files
+
+These are the files / directories that are created and/or modified with this
+install:
+
+```text
+~/.config/envman/PATH.env
+~/.local/opt/pwsh/
+~/.local/share/powershell/Modules
+```
+
+## Cheat Sheet
+
 > The core benefit of running `pwsh` on Mac or Linux is that you get a way to
 > debug Windows scripts without having to boot up Windows.
 
@@ -12,13 +27,39 @@ For example, if you want to create a `curl.exe -A "windows" | powershell` script
 for Windows (as we do), it's helpful to be able to do some level of debugging on
 other platforms.
 
-<!--
-For example, if you wanted to install Node.js with powershell and
-webinstall.dev, you can:
+### How to Use PowerShell with Vim
 
-```cmd
-curl.exe -s https://webi.ms/node@lts | powershell
+Assuming you have [vim-ale](../vim-ale/) installed - which is included with
+[vim-essentials](../vim-essentials/) - all you need to do is install the
+`PSScriptAnalyzer` module.
+
+See the "Lint & Fmt" section below.
+
+### How to Lint & Fmt ps1 Files
+
+You must install `PSScriptAnalyzer`. Then you can use `Invoke-ScriptAnalyzer`
+and `Invoke-Formatter`
+
+```sh
+pwsh -Command "Install-Module -Name PSScriptAnalyzer -Scope CurrentUser -AllowClobber"
 ```
--->
 
-<!-- TODO if, pipe, function -->
+To lint:
+
+```sh
+my_ps1='./my-file.ps1'
+pwsh -Command "Invoke-ScriptAnalyzer -Fix -ExcludeRule PSAvoidUsingWriteHost, PSUseDeclaredVarsMoreThanAssignment -Path \"$my_ps1\""
+```
+
+To fmt:
+
+```sh
+my_ps1='./my-file.ps1'
+my_text="$(
+    pwsh -Command "Invoke-Formatter -ScriptDefinition (Get-Content -Path \"$my_ps1\" -Raw)"
+)"
+printf '%s\n' "${my_text}" > "${my_ps1}"
+```
+
+Note: it is _several hundred times faster_ to lint and fmt from a native
+PowerShell script than from invoking `pwsh -Command` each time.

powershell/releases.js

@@ -8,6 +8,11 @@ module.exports = function (request) {
   return github(request, owner, repo).then(function (all) {
     // remove checksums and .deb
     all.releases = all.releases.filter(function (rel) {
+      let isPreview = rel.name.includes('-preview.');
+      if (isPreview) {
+        rel.channel = 'beta';
+      }
+
       return !/(alpine)|(fxdependent)|(\.deb)|(\.pkg)|(\.rpm)$/i.test(rel.name);
     });
     return all;

rclone/install.ps1

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

rg/install.ps1

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

ripgrep/install.ps1

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