github/vim-ale
1
0
Fork 0
mirror of https://github.com/webinstall/webi-installers.git synced 2026-02-14 09:39:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(pwsh): lint+fix

Browse Source
This commit is contained in:
AJ ONeal
2023-10-18 00:03:08 -06:00
parent f98086b38e
commit 3d51b8373a
103 changed files with 849 additions and 849 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
_example/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -42,18 +42,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

2
_vim-example/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\example" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/CHANGEME/example.git "$Env:USERPROFILE\.vim\pack\plugins\start\example"
& git clone --depth=1 https://github.com/CHANGEME/example.git "$Env:USERPROFILE\.vim\pack\plugins\start\example"

4
_webi/bootstrap.ps1
View File

@@ -6,7 +6,7 @@
############################################################
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" }
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 }}"
& "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" "{{ exename }}"

24
_webi/template.ps1
View File

@@ -32,7 +32,7 @@ $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
@@ -94,16 +94,16 @@ 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 ""
}
}
@@ -118,4 +118,4 @@ webi_path_add ~/.local/bin
webi_path_add ~/.local/bin
# Done
popd
Pop-Location

54
_webi/webi-pwsh.ps1
View File

@@ -32,7 +32,7 @@ $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
@@ -53,7 +53,7 @@ if (!(Test-Path -Path .local\tmp)) {
# 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"
}
@@ -63,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
}
@@ -101,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
@@ -109,4 +109,4 @@ echo "Downloading $PKG_URL"
powershell .\.local\tmp\$exename.install.ps1
# Done
popd
Pop-Location

18
arc/install.ps1
View File

@@ -20,34 +20,34 @@ $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"
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"
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
# Move single binary into root of temporary folder
& move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "arc.exe"
& Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "arc.exe"
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

6
archiver/install.ps1
View File

@@ -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" }
curl.exe -fsSL "$Env:WEBI_HOST/arc@$Env:WEBI_VERSION" | powershell
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

20
atomicparsley/install.ps1
View File

@@ -21,20 +21,20 @@ $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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
awless/install.ps1
View File

@@ -21,17 +21,17 @@ $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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

24
bat/install.ps1
View File

@@ -4,44 +4,44 @@ $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"
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"
}
# Fetch MSVC Runtime
echo "Checking for 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")) {
echo "Installing $Env:PKG_NAME"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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 "bat-*\$EXENAME" "$VERNAME"
& Move-Item "bat-*\$EXENAME" "$VERNAME"
# Settle unpacked archive into place
echo "New Name: $VERNAME"
echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
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
Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

18
caddy/install.ps1
View File

@@ -21,17 +21,17 @@ $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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
chromedriver/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -41,18 +41,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
cmake/install.ps1
View File

@@ -21,34 +21,34 @@ $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"
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"
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
# 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

20
comrak/install.ps1
View File

@@ -4,34 +4,34 @@ $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"
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"
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
# Move single binary into root of temporary folder
& move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "$VERNAME"
& 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"
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
Copy-Item -Path "$Env:USERPROFILE\.local\opt\$Env:PKG_NAME-v$Env:WEBI_VERSION\bin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

22
curlie/install.ps1
View File

@@ -4,38 +4,38 @@ $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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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 "$EXENAME" "$VERNAME"
& Move-Item "$EXENAME" "$VERNAME"
# Settle unpacked archive into place
echo "New Name: $VERNAME"
echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
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
Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

18
dashcore/install.ps1
View File

@@ -21,34 +21,34 @@ $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"
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"
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
# 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
dashd/install.ps1
View File

@@ -21,34 +21,34 @@ $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"
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"
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
# 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
dashmsg/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
delta/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,11 +38,11 @@ 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"
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"
@@ -55,9 +55,9 @@ IF (!(Test-Path -Path "$pkg_src_cmd")) {
git config --global interactive.diffFilter 'delta --color-only'
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

22
deno/install.ps1
View File

@@ -2,37 +2,37 @@
# 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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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"
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
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

20
dotenv-linter/install.ps1
View File

@@ -19,24 +19,24 @@ New-Item "$Env:USERPROFILE\Downloads\webi" -ItemType Directory -Force | Out-Null
$pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
# Fetch MSVC Runtime
echo "Checking for MSVC Runtime..."
Write-Output "Checking for MSVC Runtime..."
IF (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
& "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" vcruntime
}
# Fetch archive
IF (!(Test-Path -Path "$pkg_download")) {
echo "Downloading dotenv-linter from $Env:WEBI_PKG_URL to $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 "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing dotenv-linter"
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
@@ -44,18 +44,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
dotenv/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

22
fd/install.ps1
View File

@@ -4,38 +4,38 @@ $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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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 "$EXENAME" "$VERNAME"
& Move-Item "$EXENAME" "$VERNAME"
# Settle unpacked archive into place
echo "New Name: $VERNAME"
echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
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
Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

14
ffmpeg/install.ps1
View File

@@ -20,30 +20,30 @@ $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"
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"
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
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
ffuf/install.ps1
View File

@@ -21,17 +21,17 @@ $pkg_download = "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
# Fetch archive
IF (-Not (Test-Path -Path "$pkg_download")) {
echo "Downloading ffuf from $Env:WEBI_PKG_URL to $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 "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (-Not (Test-Path -Path "$pkg_src_cmd")) {
echo "Installing ffuf"
Write-Output "Installing ffuf"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\ffuf-v*" -Recurse -ErrorAction Ignore
@@ -43,19 +43,19 @@ IF (-Not (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"
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
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 | Out-Null
New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

22
fzf/install.ps1
View File

@@ -4,38 +4,38 @@ $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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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 "$EXENAME" "$VERNAME"
& Move-Item "$EXENAME" "$VERNAME"
# Settle unpacked archive into place
echo "New Name: $VERNAME"
echo "New Location: $Env:USERPROFILE\.local\xbin\$VERNAME"
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
Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

18
gh/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -42,18 +42,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

6
git-gpg-init/install.ps1
View File

@@ -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" }
curl.exe -fsSL "$Env:WEBI_HOST/git-config-gpg@$Env:WEBI_VERSION" | powershell
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

24
git/install.ps1
View File

@@ -12,43 +12,43 @@ $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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $pkg_download"
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 = pushd "$pkg_cmd_name-v$Env:WEBI_VERSION") | Out-Null
($none = Push-Location "$pkg_cmd_name-v$Env:WEBI_VERSION") | Out-Null
& tar xf "$pkg_download"
($none = popd) | Out-Null
($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"
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
# Add to path
webi_path_add ~/.local/opt/git/cmd
webi_path_add ~/.local/opt/git/cmd

18
gitdeploy/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
gitea/install.ps1
View File

@@ -20,34 +20,34 @@ $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"
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"
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
# Move single binary into root of temporary folder
& move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "gitea.exe"
& Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "gitea.exe"
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

54
go-essentials/install.ps1
View File

@@ -7,22 +7,22 @@ if (!(Get-Command "go.exe" -ErrorAction SilentlyContinue)) {
}
# 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 ""
@@ -33,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 ""

22
go/install.ps1
View File

@@ -18,37 +18,37 @@ if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
# Fetch archive
IF (!(Test-Path -Path "$pkg_download")) {
echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $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"
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
# Unpack archive
# 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 "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"
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 }
@@ -57,4 +57,4 @@ IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Forc
webi_path_add ~/.local/opt/go/bin
# Special to go: add default GOBIN to PATH
webi_path_add ~/go/bin
webi_path_add ~/go/bin

22
golang/install.ps1
View File

@@ -18,37 +18,37 @@ if (!(Get-Command "git.exe" -ErrorAction SilentlyContinue)) {
# Fetch archive
IF (!(Test-Path -Path "$pkg_download")) {
echo "Downloading $Env:PKG_NAME from $Env:WEBI_PKG_URL to $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"
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
# Unpack archive
# 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 "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"
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 }
@@ -57,4 +57,4 @@ IF (!(Test-Path -Path go\bin)) { New-Item -Path go\bin -ItemType Directory -Forc
webi_path_add ~/.local/opt/go/bin
# Special to go: add default GOBIN to PATH
webi_path_add ~/go/bin
webi_path_add ~/go/bin

18
goreleaser/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

2
gpg-pubkey/gpg-pubkey-id.ps1
View File

@@ -5,4 +5,4 @@ gpg --list-secret-keys --keyid-format LONG |
Select-Object Line |
ForEach-Object {
$_.Line.split('/')[1].split(' ')[0]
}
}

16
gpg-pubkey/gpg-pubkey.ps1
View File

@@ -12,7 +12,7 @@ if (!$my_key_id) {
$my_email = git config --global user.email
$my_host = hostname
echo "
Write-Output "
%echo Generating RSA 3072 key
Key-Type: RSA
Key-Length: 3072
@@ -31,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 ""

12
gpg-pubkey/install.ps1
View File

@@ -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
}
}
@@ -40,4 +40,4 @@ if (!$gpg_exists) {
#
# run gpg-pubkey
#
& "$Env:USERPROFILE\.local\bin\$MY_CMD.bat"
& "$Env:USERPROFILE\.local\bin\$MY_CMD.bat"

8
gpg/install.ps1
View File

@@ -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 ""

18
gprox/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -42,18 +42,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
grype/install.ps1
View File

@@ -21,17 +21,17 @@ $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 grype from $Env:WEBI_PKG_URL to $pkg_download"
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 "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing grype"
Write-Output "Installing grype"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\grype-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"
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
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 | Out-Null
New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
hugo-extended/install.ps1
View File

@@ -21,17 +21,17 @@ $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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
hugo/install.ps1
View File

@@ -21,17 +21,17 @@ $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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

24
jq/install.ps1
View File

@@ -4,35 +4,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"
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"
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
# 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"
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"
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
Copy-Item -Path "$Env:USERPROFILE\.local\xbin\$VERNAME" -Destination "$Env:USERPROFILE\.local\bin\$EXENAME" -Recurse

18
k9s/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Remove-Item -Path "$pkg_src" -Recurse -ErrorAction Ignore

18
keypairs/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
kind/install.ps1
View File

@@ -18,28 +18,28 @@ 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"
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
Write-Output "Installing kind"
Push-Location .local\tmp
Remove-Item -Path ".\kind-v*" -Recurse -ErrorAction Ignore
Remove-Item -Path ".\kind.exe" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
echo "Install Location: $pkg_src_cmd"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
kubectx/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Remove-Item -Path "$pkg_src" -Recurse -ErrorAction Ignore

18
kubens/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Remove-Item -Path "$pkg_src" -Recurse -ErrorAction Ignore

18
lf/install.ps1
View File

@@ -18,28 +18,28 @@ 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"
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"
Write-Output "Installing lf"
pushd .local\tmp
Push-Location .local\tmp
Remove-Item -Path ".\lf.exe" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
echo "Install Location: $pkg_src_cmd"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
lsd/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
mutagen/install.ps1
View File

@@ -18,28 +18,28 @@ 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"
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"
Write-Output "Installing mutagen"
pushd .local\tmp
Push-Location .local\tmp
Remove-Item -Path ".\mutagen.exe" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
echo "Install Location: $pkg_src_cmd"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

4
myip/install.ps1
View File

@@ -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"
& "$Env:USERPROFILE\.local\bin\myip.bat"

10
myip/myip.ps1
View File

@@ -2,12 +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"
}

12
nerdfont/install.ps1
View File

@@ -6,11 +6,11 @@ $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")) {
& 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"
@@ -27,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"
}

22
node/install.ps1
View File

@@ -2,41 +2,41 @@
# 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"
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"
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
# Unpack archive
# Windows BSD-tar handles zip. Imagine that.
echo "Unpacking $Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE"
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"
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
# Add to path
webi_path_add ~/.local/opt/node
webi_path_add ~/.local/opt/node

18
ots/install.ps1
View File

@@ -19,15 +19,15 @@ $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"
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"
Write-Output "Installing ots"
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\ots-v*" -Recurse -ErrorAction Ignore
@@ -35,18 +35,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
pandoc/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
pathman/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
rclone/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,18 +38,18 @@ 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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
rg/install.ps1
View File

@@ -20,17 +20,17 @@ $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"
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"
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
@@ -38,19 +38,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"
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'"
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
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

6
ripgrep/install.ps1
View File

@@ -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" }
curl.exe -fsSL "$Env:WEBI_HOST/rg@$Env:WEBI_VERSION" | powershell
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

18
sass/install.ps1
View File

@@ -21,33 +21,33 @@ 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 sass (dart-sass) from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading sass (dart-sass) from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing sass (dart-sass)"
Write-Output "Installing sass (dart-sass)"
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\dart-sass-v*" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
echo "Install Location: $pkg_src_cmd"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null > $null
Move-Item -Path ".\dart-sass\*" -Destination "$pkg_src_dir"
# Exit tmp
popd
Pop-Location
}
Remove-Item "$pkg_dst_dir" -Force -Confirm:$False -Recurse -ErrorAction Ignore
echo "Linking '$pkg_dst_dir' from '$pkg_src_dir'"
Write-Output "Linking '$pkg_dst_dir' from '$pkg_src_dir'"
New-Item -ItemType Junction -Path "$pkg_dst_dir" -Target "$pkg_src_dir" > $null
# Add to path
webi_path_add ~/.local/opt/dart-sass
webi_path_add ~/.local/opt/dart-sass

18
sclient/install.ps1
View File

@@ -20,17 +20,17 @@ $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 sclient from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading sclient from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing sclient"
Write-Output "Installing sclient"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\sclient-*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\sclient.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
sd/install.ps1
View File

@@ -20,17 +20,17 @@ $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 sd from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading sd from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing sd"
Write-Output "Installing sd"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\sd-*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path "b\*\release\sd.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
serviceman/install.ps1
View File

@@ -20,17 +20,17 @@ $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 serviceman from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading serviceman from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing serviceman"
Write-Output "Installing serviceman"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\serviceman-v*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\serviceman.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
shellcheck/install.ps1
View File

@@ -20,17 +20,17 @@ $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 shellcheck from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading shellcheck from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing shellcheck"
Write-Output "Installing shellcheck"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\shellcheck-v*" -Recurse -ErrorAction Ignore | Out-Null
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\shellcheck*.exe" -Destination "$pkg_src_cmd"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

20
shfmt/install.ps1
View File

@@ -18,30 +18,30 @@ 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 shfmt from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading shfmt from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing shfmt"
Write-Output "Installing shfmt"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Move single binary into root of temporary folder
& move "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "shfmt.exe"
& Move-Item "$Env:USERPROFILE\Downloads\webi\$Env:WEBI_PKG_FILE" "shfmt.exe"
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path "shfmt.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
sqlpkg/install.ps1
View File

@@ -20,17 +20,17 @@ $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 sqlpkg from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading sqlpkg from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing sqlpkg"
Write-Output "Installing sqlpkg"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\sqlpkg-v*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\sqlpkg.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

4
ssh-pubkey/install.ps1
View File

@@ -4,8 +4,8 @@ $MY_CMD = "ssh-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"
# run the command
& "$Env:USERPROFILE\.local\bin\$MY_CMD.bat"
& "$Env:USERPROFILE\.local\bin\$MY_CMD.bat"

14
ssh-pubkey/ssh-pubkey.ps1
View File

@@ -24,19 +24,19 @@ if (!(Test-Path -Path "$Env:USERPROFILE/.ssh/config")) {
if (!(Test-Path -Path "$Env:USERPROFILE/.ssh/id_rsa")) {
& ssh-keygen -b 2048 -t rsa -f "$Env:USERPROFILE/.ssh/id_rsa" -q -N """"
echo ""
Write-Output ""
}
if (!(Test-Path -Path "$Env:USERPROFILE/.ssh/id_rsa.pub")) {
& ssh-keygen -y -f "$Env:USERPROFILE/.ssh/id_rsa" > "$Env:USERPROFILE/.ssh/id_rsa.pub"
echo ""
Write-Output ""
}
# TODO use the comment (if any) for the name of the file
echo ""
echo "~/Downloads/id_rsa.$Env:USERNAME.pub":
echo ""
Write-Output ""
Write-Output "~/Downloads/id_rsa.$Env:USERNAME.pub":
Write-Output ""
#rm -f "$Env:USERPROFILE/Downloads/id_rsa.$Env:USERNAME.pub":
Copy-Item -Path "$Env:USERPROFILE/.ssh/id_rsa.pub" -Destination "$Env:USERPROFILE/Downloads/id_rsa.$Env:USERNAME.pub"
& type "$Env:USERPROFILE/Downloads/id_rsa.$Env:USERNAME.pub"
echo ""
& Get-Content "$Env:USERPROFILE/Downloads/id_rsa.$Env:USERNAME.pub"
Write-Output ""

18
sttr/install.ps1
View File

@@ -20,17 +20,17 @@ $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 sttr from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading sttr from $Env:WEBI_PKG_URL to $pkg_download"
& curl.exe -A "$Env:WEBI_UA" -fsSL "$Env:WEBI_PKG_URL" -o "$pkg_download.part"
& move "$pkg_download.part" "$pkg_download"
& Move-Item "$pkg_download.part" "$pkg_download"
}
IF (!(Test-Path -Path "$pkg_src_cmd")) {
echo "Installing sttr"
Write-Output "Installing sttr"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\sttr-v*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\sttr.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

6
sudo/install.ps1
View File

@@ -1,9 +1,9 @@
#!/usr/bin/env pwsh
echo "Installing sudo.cmd..."
Write-Output "Installing sudo.cmd..."
# Couldn't figure out how to get this to work with "here strings", so forgive the ugly, but at least it works
Set-Content -Path .local\bin\sudo.cmd -Value "@echo off`r`npowershell -Command ""Start-Process cmd -Verb RunAs -ArgumentList '/c cd /d %CD% && %*'""`r`n@echo on"
echo "Installed to '$Env:USERPROFILE\.local\bin\sudo.cmd'"
echo ""
Write-Output "Installed to '$Env:USERPROFILE\.local\bin\sudo.cmd'"
Write-Output ""

18
syncthing/install.ps1
View File

@@ -20,17 +20,17 @@ $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 syncthing from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading syncthing 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 syncthing"
Write-Output "Installing syncthing"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\syncthing-*" -Recurse -ErrorAction Ignore
@@ -38,18 +38,18 @@ 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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\syncthing*\syncthing.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
terraform/install.ps1
View File

@@ -21,17 +21,17 @@ $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 terraform from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading terraform 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 terraform"
Write-Output "Installing terraform"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\terraform-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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\terraform.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

16
vcruntime/install.ps1
View File

@@ -23,19 +23,19 @@ if (-not (Test-Path "$Env:USERPROFILE\Downloads\webi\vcredist.exe")) {
ELSE {
curl.exe -o "$Env:USERPROFILE\Downloads\webi\vcredist.exe.part" -L https://aka.ms/vs/17/release/vc_redist.x64.exe
}
& move "$Env:USERPROFILE\Downloads\webi\vcredist.exe.part" "$Env:USERPROFILE\Downloads\webi\vcredist.exe"
& Move-Item "$Env:USERPROFILE\Downloads\webi\vcredist.exe.part" "$Env:USERPROFILE\Downloads\webi\vcredist.exe"
}
# TODO How to use CSIDL_SYSTEM?
# (https://learn.microsoft.com/en-us/windows/deployment/usmt/usmt-recognized-environment-variables)
if (-not (Test-Path "\Windows\System32\vcruntime140.dll")) {
echo ""
echo "Installing Microsoft Visual C++ Redistributable (vcruntime140.dll)..."
echo ""
Write-Output ""
Write-Output "Installing Microsoft Visual C++ Redistributable (vcruntime140.dll)..."
Write-Output ""
& "$Env:USERPROFILE\Downloads\webi\vcredist.exe" /install /quiet /passive /norestart
}
ELSE {
echo ""
echo "Found Microsoft Visual C++ Redistributable (vcruntime140.dll)"
echo ""
}
Write-Output ""
Write-Output "Found Microsoft Visual C++ Redistributable (vcruntime140.dll)"
Write-Output ""
}

2
vim-airline-themes/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline-themes" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/vim-airline/vim-airline-themes.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline-themes"
& git clone --depth=1 https://github.com/vim-airline/vim-airline-themes.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline-themes"

2
vim-airline/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/vim-airline/vim-airline.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline"
& git clone --depth=1 https://github.com/vim-airline/vim-airline.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-airline"

2
vim-ale/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\ale" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/dense-analysis/ale.git "$Env:USERPROFILE\.vim\pack\plugins\start\ale"
& git clone --depth=1 https://github.com/dense-analysis/ale.git "$Env:USERPROFILE\.vim\pack\plugins\start\ale"

4
vim-commentary/install.ps1
View File

@@ -12,6 +12,6 @@ Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\${my_name}" -Recurse
& git clone --depth=1 "$my_repo" "$Env:USERPROFILE\.vim\pack\plugins\start\$my_name.vim"
IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\plugin\$my_name.vim")) {
IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
curl.exe -sS -o "$Env:USERPROFILE\.vim\plugin\$my_name.vim" "$Env:WEBI_HOST/packages/${my_pkg_name}/${my_name}.vim"
}
}

2
vim-devicons/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\devicons" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/ryanoasis/vim-devicons.git "$Env:USERPROFILE\.vim\pack\plugins\start\devicons.vim"
& git clone --depth=1 https://github.com/ryanoasis/vim-devicons.git "$Env:USERPROFILE\.vim\pack\plugins\start\devicons.vim"

2
vim-go/install.ps1
View File

@@ -3,4 +3,4 @@
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-go" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/fatih/vim-go.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-go"
& git clone --depth=1 https://github.com/fatih/vim-go.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-go"

2
vim-lastplace/install.ps1
View File

@@ -3,4 +3,4 @@
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-lastplace" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/farmergreg/vim-lastplace.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-lastplace"
& git clone --depth=1 https://github.com/farmergreg/vim-lastplace.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-lastplace"

2
vim-nerdtree/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\nerdtree" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/preservim/nerdtree.git "$Env:USERPROFILE\.vim\pack\plugins\start\nerdtree.vim"
& git clone --depth=1 https://github.com/preservim/nerdtree.git "$Env:USERPROFILE\.vim\pack\plugins\start\nerdtree.vim"

2
vim-prettier/install.ps1
View File

@@ -3,4 +3,4 @@
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-prettier" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/prettier/vim-prettier.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-prettier"
& git clone --depth=1 https://github.com/prettier/vim-prettier.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-prettier"

2
vim-rust/install.ps1
View File

@@ -3,4 +3,4 @@
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\rust.vim" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/rust-lang/rust.vim "$Env:USERPROFILE\.vim\pack\plugins\start\rust.vim"
& git clone --depth=1 https://github.com/rust-lang/rust.vim "$Env:USERPROFILE\.vim\pack\plugins\start\rust.vim"

4
vim-sensible/install.ps1
View File

@@ -12,6 +12,6 @@ Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\${my_name}" -Recurse
& git clone --depth=1 "$my_repo" "$Env:USERPROFILE\.vim\pack\plugins\start\$my_name.vim"
IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\plugin\$my_name.vim")) {
IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
curl.exe -sS -o "$Env:USERPROFILE\.vim\plugin\$my_name.vim" "$Env:WEBI_HOST/packages/${my_pkg_name}/${my_name}.vim"
}
}

2
vim-shfmt/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\shfmt" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/z0mbix/vim-shfmt.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-shfmt"
& git clone --depth=1 https://github.com/z0mbix/vim-shfmt.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-shfmt"

4
vim-smartcase/install.ps1
View File

@@ -4,6 +4,6 @@ $my_name = "smartcase"
$my_pkg_name = "vim-smartcase"
IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\plugin\$my_name.vim")) {
IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
curl.exe -sS -o "$Env:USERPROFILE\.vim\plugin\$my_name.vim" "$Env:WEBI_HOST/packages/${my_pkg_name}/${my_name}.vim"
}
}

2
vim-syntastic/install.ps1
View File

@@ -4,4 +4,4 @@ IF (!(Test-Path -Path "$Env:USERPROFILE\.vim\pack\plugins\start")) {
New-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start" -ItemType Directory -Force | Out-Null
}
Remove-Item -Path "$Env:USERPROFILE\.vim\pack\plugins\start\vim-syntastic" -Recurse -ErrorAction Ignore
& git clone --depth=1 https://github.com/vim-syntastic/syntastic.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-syntastic"
& git clone --depth=1 https://github.com/vim-syntastic/syntastic.git "$Env:USERPROFILE\.vim\pack\plugins\start\vim-syntastic"

18
watchexec/install.ps1
View File

@@ -20,34 +20,34 @@ $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 watchexec from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading watchexec 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 watchexec"
Write-Output "Installing watchexec"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\watchexec-v*" -Recurse -ErrorAction Ignore
Remove-Item -Path ".\watchexec.exe" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\watchexec-*\watchexec.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

2
webi/install.ps1
View File

@@ -1,3 +1,3 @@
#!/usr/bin/env pwsh
# do nothing because this is a special case
# do nothing because this is a special case

24
wsl/install-wsl.ps1
View File

@@ -1,13 +1,13 @@
#!/usr/bin/env pwsh
echo "Installing 1 of 5 Microsoft-Windows-Subsystem-Linux (for WSL 1 and WSL 2) ..."
Write-Output "Installing 1 of 5 Microsoft-Windows-Subsystem-Linux (for WSL 1 and WSL 2) ..."
& dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
echo ""
echo "Installing 2 of 5 VirtualMachinePlatform (for WSL 2 Hyper-V) ..."
Write-Output ""
Write-Output "Installing 2 of 5 VirtualMachinePlatform (for WSL 2 Hyper-V) ..."
& dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
Function Test-CommandExists {
Function Test-CommandExist {
Param ($command)
$oldPreference = $ErrorActionPreference
$ErrorActionPreference = 'stop'
@@ -16,26 +16,26 @@ Function Test-CommandExists {
Finally { $ErrorActionPreference = $oldPreference }
}
echo ""
Write-Output ""
IF (!(Test-CommandExists wsl)) {
echo "Skipping 3 of 5: Microsoft Linux Kernel requires WSL 1 to be installed first ..."
Write-Output "Skipping 3 of 5: Microsoft Linux Kernel requires WSL 1 to be installed first ..."
}
ELSE {
echo "Installing 3 of 5 Microsoft Linux Kernel (wsl_update_x64.msi for WSL 2) ..."
Write-Output "Installing 3 of 5 Microsoft Linux Kernel (wsl_update_x64.msi for WSL 2) ..."
IF (!(Test-Path -Path "$Env:TEMP\wsl_update_x64.msi")) {
& curl.exe -f -o "$Env:TEMP\wsl_update_x64.msi" "https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi"
}
IF (!(Test-Path -Path "C:\Temp\System32\lxss\tools\kernel")) {
# NOTE: This WILL NOT work with TARGETDIR=$Env:TEMP!!
echo "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
Write-Output "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
powershell -Command "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
echo "Unpacked to C:\Temp\System32\lxss\tools\kernel"
Write-Output "Unpacked to C:\Temp\System32\lxss\tools\kernel"
}
Copy-Item -Path "C:\Temp\System32\lxss" -Destination "C:\System32" -Recurse -Force
echo "Copied to C:\System32\lxss\tools\kernel ..."
Write-Output "Copied to C:\System32\lxss\tools\kernel ..."
echo "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
Write-Output "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
powershell -Command "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
}
Start-Sleep -s 3
Start-Sleep -s 3

74
wsl/install.ps1
View File

@@ -1,13 +1,13 @@
#!/usr/bin/env pwsh
echo "Installing WSL (Windows Subsystem for Linux) ..."
echo ""
echo "Security: requires administrator approval to install"
Write-Output "Installing WSL (Windows Subsystem for Linux) ..."
Write-Output ""
Write-Output "Security: requires administrator approval to install"
IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
# From https://devblogs.microsoft.com/scripting/use-a-powershell-function-to-see-if-a-command-exists/
Function Test-CommandExists {
Function Test-CommandExist {
Param ($command)
$oldPreference = $ErrorActionPreference
$ErrorActionPreference = 'stop'
@@ -22,50 +22,50 @@ Function Test-CommandExists {
powershell -Command "Start-Process cmd -Wait -Verb RunAs -ArgumentList '/c cd /d %CD% && powershell -ExecutionPolicy Bypass $Env:TEMP\install-wsl2.ps1'"
IF (!(Test-CommandExists wsl)) {
echo "Warning: Skipping 3 of 5: Reboot Required to install WSL 2 !!"
Write-Output "Warning: Skipping 3 of 5: Reboot Required to install WSL 2 !!"
}
echo ""
Write-Output ""
IF ((Test-Path -Path "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx" )) {
echo "Skipping 4 of 5: Ubuntu Linux 20.04 already installed"
Write-Output "Skipping 4 of 5: Ubuntu Linux 20.04 already installed"
}
ELSE {
echo "Installing 4 of 5 Ubuntu Linux 20.04 (for WSL 1 and WSL 2) ..."
Write-Output "Installing 4 of 5 Ubuntu Linux 20.04 (for WSL 1 and WSL 2) ..."
curl.exe -fL -o "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx.part" https://aka.ms/wslubuntu2004
& move "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx.part" "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx"
& Move-Item "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx.part" "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx"
Add-AppxPackage "$Env:UserProfile\Downloads\webi\Ubuntu_2004_x64.appx"
}
echo ""
echo ""
echo ""
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
echo "!!! !!!"
echo "!!! ACTION REQUIRED !!!"
echo "!!! READ CAREFULLY! !!!"
echo "!!! !!!"
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output ""
Write-Output ""
Write-Output ""
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output "!!! !!!"
Write-Output "!!! ACTION REQUIRED !!!"
Write-Output "!!! READ CAREFULLY! !!!"
Write-Output "!!! !!!"
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
IF (!(Test-CommandExists wsl)) {
echo ""
echo "WSL 2 was NOT installed yet. FOLLOW these instructions:"
echo ""
echo " 1. REBOOT you computer to finish the WSL 1 install"
echo " (either click Start Menu => Restart, or run 'shutdown /r /t 5')"
echo ""
echo " 2. RE-RUN this WSL 2 installer"
echo " (WSL 2 cannot finish installing until the WSL 1 install is complete)"
echo ""
echo " 3. WSL 2 must be enabled manually. See https://webinstall.dev/wsl2"
echo ""
Write-Output ""
Write-Output "WSL 2 was NOT installed yet. FOLLOW these instructions:"
Write-Output ""
Write-Output " 1. REBOOT you computer to finish the WSL 1 install"
Write-Output " (either click Start Menu => Restart, or run 'shutdown /r /t 5')"
Write-Output ""
Write-Output " 2. RE-RUN this WSL 2 installer"
Write-Output " (WSL 2 cannot finish installing until the WSL 1 install is complete)"
Write-Output ""
Write-Output " 3. WSL 2 must be enabled manually. See https://webinstall.dev/wsl2"
Write-Output ""
Exit
}
echo ""
echo "You must ALSO run UBUNTU LINUX from the START MENU to complete the install."
echo ""
echo " - Select Ubuntu Linux from the Search menu or Start Menu"
echo " - Wait for the initialization to complete"
echo " - Choose a username (we recommend 'app') and a password"
echo ""
Write-Output ""
Write-Output "You must ALSO run UBUNTU LINUX from the START MENU to complete the install."
Write-Output ""
Write-Output " - Select Ubuntu Linux from the Search menu or Start Menu"
Write-Output " - Wait for the initialization to complete"
Write-Output " - Choose a username (we recommend 'app') and a password"
Write-Output ""

14
wsl1/install.ps1
View File

@@ -1,13 +1,13 @@
#!/usr/bin/env pwsh
echo "Installing WSL (Windows Subsystem for Linux) ..."
echo ""
echo "Security: requires administrator approval to install"
Write-Output "Installing WSL (Windows Subsystem for Linux) ..."
Write-Output ""
Write-Output "Security: requires administrator approval to install"
powershell -Command "Start-Process cmd -Verb RunAs -ArgumentList '/c cd /d %CD% && dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all'"
# /norestart
echo "!!!!!!!!!!!!!!!!!!!!!!!!!"
echo "!!! Reboot REQUIRED !!!"
echo "!!!!!!!!!!!!!!!!!!!!!!!!!"
echo ""
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output "!!! Reboot REQUIRED !!!"
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output ""

24
wsl2/install-wsl2.ps1
View File

@@ -1,13 +1,13 @@
#!/usr/bin/env pwsh
echo "Installing 1 of 3 Microsoft-Windows-Subsystem-Linux ..."
Write-Output "Installing 1 of 3 Microsoft-Windows-Subsystem-Linux ..."
& dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
echo ""
echo "Installing 2 of 3 VirtualMachinePlatform ..."
Write-Output ""
Write-Output "Installing 2 of 3 VirtualMachinePlatform ..."
& dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
Function Test-CommandExists {
Function Test-CommandExist {
Param ($command)
$oldPreference = $ErrorActionPreference
$ErrorActionPreference = 'stop'
@@ -16,27 +16,27 @@ Function Test-CommandExists {
Finally { $ErrorActionPreference = $oldPreference }
}
echo ""
Write-Output ""
IF (!(Test-CommandExists wsl)) {
echo "Skipping 3 of 3: Microsoft Linux Kernel requires WSL 1 to be installed first ..."
Write-Output "Skipping 3 of 3: Microsoft Linux Kernel requires WSL 1 to be installed first ..."
}
ELSE {
echo "Installing 3 of 3 Microsoft Linux Kernel (wsl_update_x64.msi) ..."
Write-Output "Installing 3 of 3 Microsoft Linux Kernel (wsl_update_x64.msi) ..."
IF (!(Test-Path -Path "$Env:TEMP\wsl_update_x64.msi")) {
& curl.exe -f -o "$Env:TEMP\wsl_update_x64.msi" "https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi"
}
IF (!(Test-Path -Path "C:\Temp\System32\lxss\tools\kernel")) {
# NOTE: This WILL NOT work with TARGETDIR=$Env:TEMP!!
echo "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
Write-Output "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
powershell -Command "Start-Process msiexec -Wait -ArgumentList '/a ""$Env:TEMP\wsl_update_x64.msi"" /quiet /qn TARGETDIR=""C:\Temp""'"
echo "Unpacked to C:\Temp\System32\lxss\tools\kernel"
Write-Output "Unpacked to C:\Temp\System32\lxss\tools\kernel"
}
Copy-Item -Path "C:\Temp\System32\lxss" -Destination "C:\System32" -Recurse -Force
echo "Copied to C:\System32\lxss\tools\kernel ..."
Write-Output "Copied to C:\System32\lxss\tools\kernel ..."
echo "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
Write-Output "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
powershell -Command "Start-Process msiexec -Wait -ArgumentList '/i','$Env:TEMP\wsl_update_x64.msi','/quiet','/qn'"
}
Start-Sleep -s 3
Start-Sleep -s 3

90
wsl2/install.ps1
View File

@@ -1,17 +1,17 @@
#!/usr/bin/env pwsh
echo "Installing WSL 2 (Windows Subsystem for Linux with Hyper-V) ..."
echo ""
echo "Security: requires administrator approval to install"
Write-Output "Installing WSL 2 (Windows Subsystem for Linux with Hyper-V) ..."
Write-Output ""
Write-Output "Security: requires administrator approval to install"
IF ($Env:WEBI_HOST -eq $null -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
IF ($null -eq $Env:WEBI_HOST -or $Env:WEBI_HOST -eq "") { $Env:WEBI_HOST = "https://webinstall.dev" }
$MYPWD = (Get-Item .).FullName
& curl.exe -fA "MS" -o "$Env:TEMP\install-wsl2.ps1" "$Env:WEBI_HOST/packages/wsl2/install-wsl2.ps1"
powershell -Command "Start-Process cmd -Wait -Verb RunAs -ArgumentList '/c cd /d %CD% && powershell -ExecutionPolicy Bypass $Env:TEMP\install-wsl2.ps1'"
# From https://devblogs.microsoft.com/scripting/use-a-powershell-function-to-see-if-a-command-exists/
Function Test-CommandExists {
Function Test-CommandExist {
Param ($command)
$oldPreference = $ErrorActionPreference
$ErrorActionPreference = 'stop'
@@ -21,47 +21,47 @@ Function Test-CommandExists {
}
IF (!(Test-CommandExists wsl)) {
echo ""
echo ""
echo ""
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
echo "!!! !!!"
echo "!!! READ CAREFULLY !!!"
echo "!!! !!!"
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
echo ""
echo "WSL 2 was NOT installed yet. You MUST follow these instructions:"
echo ""
echo " 1. REBOOT you computer to finish the WSL 1 install"
echo " (either click Start Menu => Restart, or run 'shutdown /r /t 5')"
echo ""
echo " 2. RE-RUN this WSL 2 installer"
echo " (WSL 2 cannot finish installing until the WSL 1 install is complete)"
echo ""
echo " 3. Download and Install Linux"
echo " (see https://webinstall.dev/wsl2)"
echo ""
Write-Output ""
Write-Output ""
Write-Output ""
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output "!!! !!!"
Write-Output "!!! READ CAREFULLY !!!"
Write-Output "!!! !!!"
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output ""
Write-Output "WSL 2 was NOT installed yet. You MUST follow these instructions:"
Write-Output ""
Write-Output " 1. REBOOT you computer to finish the WSL 1 install"
Write-Output " (either click Start Menu => Restart, or run 'shutdown /r /t 5')"
Write-Output ""
Write-Output " 2. RE-RUN this WSL 2 installer"
Write-Output " (WSL 2 cannot finish installing until the WSL 1 install is complete)"
Write-Output ""
Write-Output " 3. Download and Install Linux"
Write-Output " (see https://webinstall.dev/wsl2)"
Write-Output ""
Exit
}
echo ""
echo ""
echo ""
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
echo "!!! !!!"
echo "!!! READ CAREFULLY !!!"
echo "!!! !!!"
echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
echo ""
echo "WSL 2 is now installed, HOWEVER, you MUST:"
echo ""
echo "However, you still MUST INSTALL LINUX:"
echo ""
echo " 1. Download and Install Ubuntu Linux"
echo " (see https://webinstall.dev/wsl2)"
echo ""
echo " 2. Set WSL to use WSL 2 with Hyper-V. For example:"
echo " wsl.exe --set-version Ubuntu-20.04 2"
echo " wsl.exe --set-default-version 2"
echo ""
Write-Output ""
Write-Output ""
Write-Output ""
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output "!!! !!!"
Write-Output "!!! READ CAREFULLY !!!"
Write-Output "!!! !!!"
Write-Output "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
Write-Output ""
Write-Output "WSL 2 is now installed, HOWEVER, you MUST:"
Write-Output ""
Write-Output "However, you still MUST INSTALL LINUX:"
Write-Output ""
Write-Output " 1. Download and Install Ubuntu Linux"
Write-Output " (see https://webinstall.dev/wsl2)"
Write-Output ""
Write-Output " 2. Set WSL to use WSL 2 with Hyper-V. For example:"
Write-Output " wsl.exe --set-version Ubuntu-20.04 2"
Write-Output " wsl.exe --set-default-version 2"
Write-Output ""

20
xsv/install.ps1
View File

@@ -21,20 +21,20 @@ $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 xsv from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading xsv 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 xsv"
Write-Output "Installing xsv"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
# Remove any leftover tmp cruft
Remove-Item -Path ".\xsv-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"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\xsv.exe" -Destination "$pkg_src_bin"
# Exit tmp
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 | Out-Null
New-Item "$pkg_dst_bin" -ItemType Directory -Force | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
xz/install.ps1
View File

@@ -20,23 +20,23 @@ $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 xz from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading xz 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 xz"
Write-Output "Installing xz"
# TODO: create package-specific temp directory
# Enter tmp
pushd .local\tmp
Push-Location .local\tmp
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
# Settle unpacked archive into place
echo "Install Location: $pkg_src_cmd"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\bin_x86-64\xz.exe" -Destination "$pkg_src_bin"
Move-Item -Path ".\bin_x86-64\xzdec.exe" -Destination "$pkg_src_bin"
@@ -45,9 +45,9 @@ IF (!(Test-Path -Path "$pkg_src_cmd")) {
Copy-Item -Path "$pkg_src_bin\lzmadec.exe" -Destination "$pkg_src_bin\unlzma.exe"
# Exit tmp
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

18
yq/install.ps1
View File

@@ -14,28 +14,28 @@ 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 yq from $Env:WEBI_PKG_URL to $pkg_download"
Write-Output "Downloading yq 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 yq"
pushd .local\tmp
Write-Output "Installing yq"
Push-Location .local\tmp
Remove-Item -Path ".\yq-v*" -Recurse -ErrorAction Ignore
Remove-Item -Path ".\yq.exe" -Recurse -ErrorAction Ignore
echo "Unpacking $pkg_download"
Write-Output "Unpacking $pkg_download"
& tar xf "$pkg_download"
echo "Install Location: $pkg_src_cmd"
Write-Output "Install Location: $pkg_src_cmd"
New-Item "$pkg_src_bin" -ItemType Directory -Force | Out-Null
Move-Item -Path ".\yq*.exe" -Destination "$pkg_src_cmd"
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 | Out-Null
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse
Copy-Item -Path "$pkg_src" -Destination "$pkg_dst" -Recurse

Some files were not shown because too many files have changed in this diff Show More