The Disk should be formatted with a case insensitive file system (default).

Install VMWare tools daemon.

  - you should be able to do this from the vSphere UI, but I got errors with Mojave.
  - backup plan: https://my.vmware.com/web/vmware/details?productId=742&downloadGroup=VMTOOLS1032
    and then copy the darwin.iso to the host and install it manually.
  - open security preferences and click "Allow" on blocked software install from VMware
  - reboot
  - make sure you can run and see:

    $ /Library/Application Support/VMware Tools/vmware-tools-daemon --cmd "info-get guestinfo.name"
    No value value

Download Go 1.13.4 or newer tarball via curl (bootstrap version of Go must be signed and notorized in macOS version >= 10.15).

tar -xf <go.darwin-amd64.tar.gz>

mv go $HOME/goboot

System Preferences > Software Update > off

System Preferences > Desktop & Screensaver > never screensaver

System Preferences > Energy Saver > never sleep

System Preferences > Sharing > enable ssh (enable for administrators)

Create executable $HOME/stage0.sh with:

   #!/bin/bash
   while true; do (curl -v http://172.17.20.2:8713/stage0/$(sw_vers -productVersion) | sh); sleep 5; done

chmod +x $HOME/stage0.sh

Automator:

    File > New > Application
    [+] Run shell script
    [ open -a Terminal.app $HOME/stage0.sh ]
    Save to desktop as "run-builder"

System Preferences > Users & Groups > auto-login "gopher" user, run Desktop/run-builder (automator app)

passwordless sudo:

   sudo visudo
   Change line from:
    %admin ALL=(ALL) ALL
   to:
    %admin ALL=(ALL) NOPASSWD: ALL

install xcode
  - Version < 10.9: search and install an older compatible version of Xcode.
  - Versions 10.10, 10.9: running git first time will prompt for install.
  - Version => 10.15: download Xcode from the Apple Developer site.

verbose boot: (text instead of apple image)

    sudo nvram boot-args="-v"

run-builder-darwin-10_11.sh
