Office 365 Now in the Mac App Store -- VPP available?

Thanks @snourse for starting the conversation. I too just read this and wondered if this could solve some issues with deploying Office. I am sure more data will be coming over this. I should check the slack forum too.

Might check out the webinar today (2 pm CST) with Bill Smith from Jamf and Paul Bowden from Microsoft.

• https://www.jamf.com/events/webinars/how-to-manage-microsoft-office-2019-for-mac/

I guess I registered too late for it :-(

@krispayne same here...

Hi @scott.secrest, will this webinar be rebroadcast?

Wish we were O365 ... bummed we won't be able to do VPP w/ our volume licensing. Exciting times for everybody else though!

I added Outlook to Self Service for myself already. Biggest thing I'm curious about is if it will install cleanly over the previous installs. My users would LOVE to not have to install the entire suite, and I would love to stop maintaining a package.

After about 12 keychain prompts, using the App Store version now. Obviously had to remove the previous app before I could install the App Store version. Got a few free VPP licenses, too.

https://docs.microsoft.com/en-us/deployoffice/mac/deploy-mac-app-store

@krispayne @ACMT Bummer! It should be recorded. Webinars typically get posted to the youtube channel.

• https://www.youtube.com/user/JAMFMedia

Is there any way we can get the whole Microsoft Office 365 bundle as a single VPP app? That would be extremely handy... Even though I like the option to have users install the apps they want, if we could provide a one click option for everyone that would be even easier.

FYI, I was just able to purchase Office apps via Apple Business Manager.

Hi,

So here's a small starter for removing the non-MAS apps, and triggering the MAS apps to install.

Step list;

• Get your apps via the VPP / Apple Business Manager portal
• Assign the apps in Jamf Pro to your desired users / computers
• Push an updated PPPC profile for the Contacts access
• pkill the applications and rm - rf them (script below)
• rm the licensing helper
• Remove 5 keychain entries (@pbowden is working on some magic)
• Trigger a recon and the new apps will be installed

In my small script its looping till OneDrive is there, and when found its being opened to prevent users dataloss.

#!/bin/bash

# Removes the office CDN 365 include OneDrive applications.

# The first parameter is used to kill the app. It should be the app name or path
# as required by the pkill command.
applicationWord="Microsoft Word"
applicationExcel="Microsoft Excel"
applicationOneNote="Microsoft OneNote"
applicationOutlook="Microsoft Outlook"
applicationPowerpoint="Microsoft Powerpoint"
applicationOneDrive="OneDrive"

### Checking for valid arguments ###
if [[ -z "${applicationWord}" ]]; then
    echo "No Word application found!"
    exit 1
fi

if [[ -z "${applicationExcel}" ]]; then
    echo "No Excel application found!"
    exit 1
fi

if [[ -z "${applicationOneNote}" ]]; then
    echo "No OneNote application found!"
    exit 1
fi

if [[ -z "${applicationOutlook}" ]]; then
    echo "No Outlook application found!"
    exit 1
fi

if [[ -z "${applicationPowerpoint}" ]]; then
    echo "No Powerpoint application found!"
    exit 1
fi

if [[ -z "${applicationOneDrive}" ]]; then
    echo "No OneDrive application found!"
    exit 1
fi


### Quitting Applications ###
echo "Closing application: ${applicationWord}"
    pkill "${applicationWord}"

echo "Closing application: ${applicationExcel}"
    pkill "${applicationExcel}"

echo "Closing application: ${applicationOneNote}"
    pkill "${applicationOneNote}"

echo "Closing application: ${applicationOutlook}"
    pkill "${applicationOutlook}"

echo "Closing application: ${applicationPowerpoint}"
    pkill "${applicationPowerpoint}"

echo "Closing application: ${applicationOneDrive}"
    pkill "${applicationOneDrive}"


### Removing Applications ###
echo "Removing application: ${applicationWord}"
    rm -rf "/Applications/${applicationWord}.app"

echo "Removing application: ${applicationExcel}"
    rm -rf "/Applications/${applicationExcel}.app"

echo "Removing application: ${applicationOneNote}"
    rm -rf "/Applications/${applicationOneNote}.app"

echo "Removing application: ${applicationOutlook}"
rm -rf "/Applications/${applicationOutlook}.app"

echo "Removing application: ${applicationPowerpoint}"
    rm -rf "/Applications/${applicationPowerpoint}.app"

echo "Removing application: ${applicationOneDrive}"
    rm -rf "/Applications/${applicationOneDrive}.app"

# Take a small nap.
    sleep 05

### Recon to trigger assigned VPP applications ###
    /usr/local/jamf/bin/jamf recon


### Looping till OneDrive.app has been installed and open it so that user is logging back in to prevent data-loss.
    while [ ! -f /Applications/OneDrive.app/Contents/Info.plist ];
    do
    sleep 1;
    done;
    sleep 05;
    open -a /Applications/OneDrive.app;


exit

Hi everyone!

Just letting you know, yes, the US version of the webinar with @pbowden and me was recorded and as soon as our marketing folks have done some editing and cleanup it will be posted. I'm hoping next week.

I'm also working on a new Jamf Blog post as a follow up to our webinar. It'll be in Question/Answer format. Technically, the Mac App Store announcement was a "One more thing..." rather than something related to the main content about plists and profiles, however, I'll include links to any resources for how best to transition from package-installed apps to VPP apps if they're available at the time.

@txhaflaire has done an excellent job getting a removal script started! Paul has identified five keychain entries that need to be removed to help make the transition. Removing those entries should alleviate the keychain prompts. He's still testing and experimenting and will probably give us more guidance in the next week or two.

For brand new Office installs using the Mac App Store and volume purchasing, the keychain prompts don't come into play. They're only related to transitioning from package-installed apps. However, we've received advice from some folks that you may run into keychain prompts if you download and launch apps from the Mac App Store at different times. In other words, work to download all the apps first and then let users start using them.

Deploying a suite of apps is new territory for many of us! Share your discoveries and share your mistakes.

FWIW, I came up with the following for an EA to distinguish MAS and non-MAS versions of Office. If it detects any MAS issued app, it assumes they all are:

#!/bin/bash

ls -d /Applications/Microsoft [EOPW][noux]*.app/Contents/_MASReceipt 1>/dev/null && echo '<result>Mac App Store</result>' || echo '<result>MS CDN</result>'

Just posting the keychain removal script from @pbowden 's GitHub.

I'm thinking I'll build this together with @txhaflaire's script and try for "the one script to convert them all" to MAS.

#!/bin/sh
#set -x

TOOL_NAME="Microsoft Office 2019/2016 Keychain Removal Tool"
TOOL_VERSION="2.5"

## Copyright (c) 2019 Microsoft Corp. All rights reserved.
## Scripts are not supported under any Microsoft standard support program or service. The scripts are provided AS IS without warranty of any kind.
## Microsoft disclaims all implied warranties including, without limitation, any implied warranties of merchantability or of fitness for a 
## particular purpose. The entire risk arising out of the use or performance of the scripts and documentation remains with you. In no event shall
## Microsoft, its authors, or anyone else involved in the creation, production, or delivery of the scripts be liable for any damages whatsoever 
## (including, without limitation, damages for loss of business profits, business interruption, loss of business information, or other pecuniary 
## loss) arising out of the use of or inability to use the sample scripts or documentation, even if Microsoft has been advised of the possibility
## of such damages.
## Feedback: pbowden@microsoft.com

# Constants
WORD2016PATH="/Applications/Microsoft Word.app"
EXCEL2016PATH="/Applications/Microsoft Excel.app"
POWERPOINT2016PATH="/Applications/Microsoft PowerPoint.app"
OUTLOOK2016PATH="/Applications/Microsoft Outlook.app"
ONENOTE2016PATH="/Applications/Microsoft OneNote.app"
SCRIPTPATH=$( cd $(dirname $0) ; pwd -P )

function ShowUsage {
# Shows tool usage and parameters
    echo $TOOL_NAME - $TOOL_VERSION
    echo "Purpose: Removes Office 2019/2016 for Mac keychain entries for 15.x and 16.x builds"
    echo "Usage: NukeOffKey [--Default] [--IRM] [--All] [--Force] [--Jamf] [--MAS]"
    echo "         [--Default] removes the logon, cache and ADAL keychain entries"
    echo "         [--IRM] removes the rights management keychain entries"
    echo "         [--All] removes logon, cache, ADAL, rights management and HelpShift keychain entries"
    echo "         [--Jamf] ignores the first 3 parameters for running via Jamf"
    echo "         [--MAS] removes the entries required for a clean CDN to Mac App Store conversion"
    echo
    exit 0
}

# Check that all keychain-integrated applications are not running
function CheckRunning {
    OPENAPPS=0
    WORDRUNSTATE=$(CheckLaunchState "$WORD2016PATH")
    if [ "$WORDRUNSTATE" == "1" ]; then
        OPENAPPS=$(($OPENAPPS + 1))
    fi
    EXCELRUNSTATE=$(CheckLaunchState "$EXCEL2016PATH")
    if [ "$EXCELRUNSTATE" == "1" ]; then
        OPENAPPS=$(($OPENAPPS + 1))
    fi
    POWERPOINTRUNSTATE=$(CheckLaunchState "$POWERPOINT2016PATH")
    if [ "$POWERPOINTRUNSTATE" == "1" ]; then
        OPENAPPS=$(($OPENAPPS + 1))
    fi
    OUTLOOKRUNSTATE=$(CheckLaunchState "$OUTLOOK2016PATH")
    if [ "$OUTLOOKRUNSTATE" == "1" ]; then
        OPENAPPS=$(($OPENAPPS + 1))
    fi
    ONENOTERUNSTATE=$(CheckLaunchState "$ONENOTE2016PATH")
    if [ "$ONENOTERUNSTATE" == "1" ]; then
        OPENAPPS=$(($OPENAPPS + 1))
    fi
    if [ "$OPENAPPS" != "0" ]; then
        echo "1"
    else
        echo "0"
    fi
}

# Checks to see if a process is running
function CheckLaunchState {
    APPPATH="$1"
    local RUNNING_RESULT=$(ps ax | grep -v grep | grep "$APPPATH")
    if [ "${#RUNNING_RESULT}" -gt 0 ]; then
        echo "1"
    else
        echo "0"
    fi
}

# Checks to see if the user has root-level permissions
function GetSudo {
    if [ "$EUID" != "0" ]; then
        sudo -p "Enter administrator password: " echo
        if [ $? -eq 0 ] ; then
            echo "0"
        else
            echo "1"
        fi
    fi
}

# Forcibly terminates a process
function ForceTerminate {
    PROCESS="$1"
    $(ps ax | grep -v grep | grep "$PROCESS" | awk '{print $1}' | xargs kill -9 2> /dev/null 1> /dev/null)
}

# Forcibly quits all Office 2019/2016 apps
function ForceQuit2016 {
    ForceTerminate "$WORD2016PATH"
    ForceTerminate "$EXCEL2016PATH"
    ForceTerminate "$POWERPOINT2016PATH"
    ForceTerminate "$OUTLOOK2016PATH"
    ForceTerminate "$ONENOTE2016PATH"
}

# Checks to see if 'Microsoft Office Credentials' for ADAL entries are present in the keychain
function FindEntryMsoCredentialSchemeADAL {
    /usr/bin/security find-internet-password -s 'msoCredentialSchemeADAL' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the first 'Microsoft Office Credentials' for ADAL entry from the keychain
function RemoveEntryMsoCredentialSchemeADAL {
    /usr/bin/security delete-internet-password -s 'msoCredentialSchemeADAL' 2> /dev/null 1> /dev/null
}

# Checks to see if 'Microsoft Office Credentials' for LiveID entries are present in the keychain
function FindEntryMsoCredentialSchemeLiveId {
    /usr/bin/security find-internet-password -s 'msoCredentialSchemeLiveId' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the first 'Microsoft Office Credentials' for LiveID entry from the keychain
function RemoveEntryMsoCredentialSchemeLiveId {
    /usr/bin/security delete-internet-password -s 'msoCredentialSchemeLiveId' 2> /dev/null 1> /dev/null
}

# Checks to see if 'MSOpenTech.ADAL.1*' entries are present in the keychain
function FindEntryMSOpenTechADAL1 {
    /usr/bin/security find-generic-password -G 'MSOpenTech.ADAL.1' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the first 'MSOpenTech.ADAL.1*' entry from the keychain
function RemoveEntryMSOpenTechADAL1 {
    /usr/bin/security delete-generic-password -G 'MSOpenTech.ADAL.1' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Microsoft Office Identities Cache 2' entry is present in the keychain (15.x builds)
function FindEntryOfficeIdCache2 {
    /usr/bin/security find-generic-password -l 'Microsoft Office Identities Cache 2' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Microsoft Office Identities Cache 2' entry from the keychain (15.x builds)
function RemoveEntryOfficeIdCache2 {
    /usr/bin/security delete-generic-password -l 'Microsoft Office Identities Cache 2' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Microsoft Office Identities Cache 3' entry is present in the keychain (16.x builds)
function FindEntryOfficeIdCache3 {
    /usr/bin/security find-generic-password -l 'Microsoft Office Identities Cache 3' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Microsoft Office Identities Cache 3' entry from the keychain (16.x builds)
function RemoveEntryOfficeIdCache3 {
    /usr/bin/security delete-generic-password -l 'Microsoft Office Identities Cache 3' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Microsoft Office Identities Settings 2' entry is present in the keychain (15.x builds)
function FindEntryOfficeIdSettings2 {
    /usr/bin/security find-generic-password -l 'Microsoft Office Identities Settings 2' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Microsoft Office Identities Settings 2' entry from the keychain (15.x builds)
function RemoveEntryOfficeIdSettings2 {
    /usr/bin/security delete-generic-password -l 'Microsoft Office Identities Settings 2' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Microsoft Office Identities Settings 3' entry is present in the keychain (16.x builds)
function FindEntryOfficeIdSettings3 {
    /usr/bin/security find-generic-password -l 'Microsoft Office Identities Settings 3' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Microsoft Office Identities Settings 3' entry from the keychain (16.x builds)
function RemoveEntryOfficeIdSettings3 {
    /usr/bin/security delete-generic-password -l 'Microsoft Office Identities Settings 3' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Microsoft Office Ticket Cache' entry is present in the keychain (16.x builds)
function FindEntryOfficeTicketCache {
    /usr/bin/security find-generic-password -l 'Microsoft Office Ticket Cache' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Microsoft Office Ticket Cache' entry from the keychain (16.x builds)
function RemoveEntryOfficeTicketCache {
    /usr/bin/security delete-generic-password -l 'Microsoft Office Ticket Cache' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'com.microsoft.adalcache' entry is present in the keychain (16.x builds)
function FindEntryAdalCache {
    /usr/bin/security find-generic-password -l 'com.microsoft.adalcache' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'com.microsoft.adalcache' entry from the keychain (16.x builds)
function RemoveEntryAdalCache {
    /usr/bin/security delete-generic-password -l 'com.microsoft.adalcache' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'com.helpshift.data_com.microsoft.Outlook' entry is present in the keychain
function FindEntryHelpShift {
    /usr/bin/security find-generic-password -l 'com.helpshift.data_com.microsoft.Outlook' 2> /dev/null 1> /dev/null
    echo $?
}

# Checks to see if the 'com.helpshift.data_com.microsoft.Outlook' entry is present in the keychain
function FindEntryHelpShift {
    /usr/bin/security find-generic-password -l 'com.helpshift.data_com.microsoft.Outlook' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'com.helpshift.data_com.microsoft.Outlook' entry from the keychain
function RemoveEntryHelpShift {
    /usr/bin/security delete-generic-password -l 'com.helpshift.data_com.microsoft.Outlook' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'MicrosoftOfficeRMSCredential' entry is present in the keychain
function FindEntryRMSCredential {
    /usr/bin/security find-generic-password -l 'MicrosoftOfficeRMSCredential' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'MicrosoftOfficeRMSCredential' entry from the keychain
function RemoveEntryRMSCredential {
    /usr/bin/security delete-generic-password -l 'MicrosoftOfficeRMSCredential' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'MSProtection.framework.service' entry is present in the keychain
function FindEntryMSProtection {
    /usr/bin/security find-generic-password -l 'MSProtection.framework.service' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'MSProtection.framework.service' entry from the keychain
function RemoveEntryMSProtection {
    /usr/bin/security delete-generic-password -l 'MSProtection.framework.service' 2> /dev/null 1> /dev/null
}

# Checks to see if the 'Exchange' entry is present in the keychain
function FindEntryExchange {
    /usr/bin/security find-generic-password -l 'Exchange' 2> /dev/null 1> /dev/null
    echo $?
}

# Removes the 'Exchange' entry from the keychain
function RemoveEntryExchange {
    /usr/bin/security delete-generic-password -l 'Exchange' 2> /dev/null 1> /dev/null
}

# Evaluate command-line arguments
if [[ $# = 0 ]]; then
    ShowUsage
else
  # If running under Jamf there will be three arguments provided by Jamf, check for user provided --Jamf argument.
  if [[ $# -gt 3 ]]; then
    for KEY in "$@"
    do
      if [[ "$KEY" =~ ^(--jamf|--Jamf)$ ]]; then
        shift 3 # Running under Jamf, ignore first three arguments
      fi
    done
  fi
    for KEY in "$@"
    do
    case $KEY in
        --Help|-h|--help)
        ShowUsage
        shift # past argument
        ;;
        --Default|-d|--default)
        REMOVEDEFAULT=true
        shift # past argument
    ;;
        --IRM|-i|--irm)
        REMOVEIRM=true
        shift # past argument
    ;;
        --All|-a|--all)
        REMOVEALL=true
        shift # past argument
    ;;
        --Jamf|-j|--jamf)
        JAMF=true
        shift # past argument
    ;;
    --MAS|-m|--mas)
        MASCONVERT=true
        shift # past argument
    ;;
    --Force|-f|--force)
        FORCE=true
        shift # past argument
    ;;
    '') #ignore empty string arguments passed by Jamf
        shift # past argument
    ;;
    *)
        ShowUsage
        ;;
    esac
    shift # past argument or value
    done
fi

## Main
# Start Removal Routine
APPSRUNNING=$(CheckRunning)
if [ "$APPSRUNNING" == "1" ]; then
    if [ $FORCE ]; then
        ForceQuit2016
    else
        echo "ERROR: Office 2019/2016 apps are open. Either close the apps, or use the '--Force' option."
        echo
        exit 1
    fi
fi

if [ $REMOVEDEFAULT ] || [ $REMOVEALL ] || [ $MASCONVERT ]; then    
    # Find and remove 'msoCredentialSchemeADAL' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryMsoCredentialSchemeADAL)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryMsoCredentialSchemeADAL
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryMsoCredentialSchemeADAL)
    done

    # Find and remove 'msoCredentialSchemeLiveId' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryMsoCredentialSchemeLiveId)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryMsoCredentialSchemeLiveId
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryMsoCredentialSchemeLiveId)
    done

    # Find and remove 'com.microsoft.adalcache' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryAdalCache)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryAdalCache
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryAdalCache)
    done

    echo "Credential keychain entries removed"
fi

if [ $REMOVEDEFAULT ] || [ $REMOVEALL ]; then   
    # Find and remove 'MSOpenTech.ADAL.1*' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryMSOpenTechADAL1)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryMSOpenTechADAL1
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryMSOpenTechADAL1)
    done

    # Find and remove 'Microsoft Office Identities Cache 2' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryOfficeIdCache2)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryOfficeIdCache2
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryOfficeIdCache2)
    done

    # Find and remove 'Microsoft Office Identities Cache 3' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryOfficeIdCache3)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryOfficeIdCache3
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryOfficeIdCache3)
    done

    # Find and remove 'Microsoft Office Identities Settings 2' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryOfficeIdSettings2)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryOfficeIdSettings2
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryOfficeIdSettings2)
    done

    # Find and remove 'Microsoft Office Identities Settings 3' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryOfficeIdSettings3)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryOfficeIdSettings3
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryOfficeIdSettings3)
    done

    # Find and remove 'Microsoft Office Ticket Cache' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryOfficeTicketCache)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryOfficeTicketCache
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryOfficeTicketCache)
    done

    # Find and remove 'Exchange' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryExchange)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryExchange
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryExchange)
    done

    echo "Default keychain entries removed"
fi

if [ $REMOVEIRM ] || [ $REMOVEALL ]; then   
    # Find and remove 'MicrosoftOfficeRMSCredential' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryRMSCredential)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryRMSCredential
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryRMSCredential)
    done

    # Find and remove 'MSProtection.framework.service' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryMSProtection)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryMSProtection
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryMSProtection)
    done
    echo "Rights Management keychain entries removed"
fi

if [ $REMOVEALL ] || [ $MASCONVERT ]; then
    # Find and remove 'com.helpshift.data_com.microsoft.Outlook' entries
    MAXCOUNT=0
    KEYNOTPRESENT=$(FindEntryHelpShift)
    while [ "$KEYNOTPRESENT" == "0" ] || [ $MAXCOUNT -gt 20 ]; do
        RemoveEntryHelpShift
        let MAXCOUNT=MAXCOUNT+1
        KEYNOTPRESENT=$(FindEntryHelpShift)
    done
    echo "HelpShift keychain entries removed"
fi

echo
exit 0

Gabe Shackney
Princeton Public Schools

@ACMT: The webinar mentioned by @scott.secrest has been posted on youtube.

Here's a link: How to Manage Microsoft Office 2019 for Mac

Description: Mac and Microsoft; is there a better hardware/software duo out there? We think not. Millions are empowered every day by utilizing the productivity tools Microsoft offers and the simple user experience Mac delivers. But, IT often struggles with keeping their Microsoft software current on their growing fleet of Mac computers. Well, not anymore.

In our webinar, How to Manage Microsoft Office 2019 for Mac, Paul Bowden of Microsoft and Bill Smith of Jamf explain old, new and better ways of installing Office 2019 for Mac.

following

also following

I reviewed the all the material in this thread.
Patience with me please as I'm not a Microsoft Office expert.
We are a larger K-12 school division with a volume license for Office 365.

The webinar posted on Youtube seems to indicate that you can switch your Volume License to use the VPP Office 365 apps. However after reviewing https://docs.microsoft.com/en-us/deployoffice/mac/deploy-mac-app-store it seems to indicate that using the Volume Serializer will cause the program to enter reduced functionality mode. I tested this and it is correct from my testing this morning.

How can I switch our Office deploys to using the VPP store instead? Using the Mac App Store for deployment is better since I don't have to manage the updates with Jamf Patch Management as it is important to keep the updates cached since bandwidth is a concern. We have Mac Minis at each school setup specifically for caching Mac App Store apps.

Any insight would be helpful, even if it's a "not possible" answer too. Thanks!

Following this as a whole, but to be clear, there are three methods of licensing the current Mac version of MS Office. Volume, individual perpetual, and Office 365 subscription licensing. For purposes of this post, I will put aside feature set differences and focus on licensing and deployment equally.

For Volume licensing, you CANNOT deploy the Mac App Store version. As such, the SKUless unlicensed PKG along with the Volume License Serializer is the ONLY option.

For Office 365 licensing, you could deploy the SKUless PKG from Microsoft and immediately activate it with an Office 365 account on first launch. Alternatively you could use the Mac App Store download and do the same thing. You CANNOT however download the Mac App Store version and use the Volume License Serializer on it.

Now that we have recited that here’s where it gets crazy. My organization has the ability to license both ways. Every user has an A3 Office 365 license that allows them to install on up to 5 computers (Mac or Windows). We also have a volume license that covers anywhere we need to deploy.

Given that, I’ve been using the volume build on corporate-owned equipment leaving the end users to use their Office 365 licensing at home.

Unfortunately now I must muddy the water a bit more. Feature set wise, the versions are NOT identical. The new REST API for Outlook is only present on the Office 365 build. In other words if I have Mac users that heavily use shared calendaring, I switch their license to Office 365 (MS-supplied build)

For now I do not use the Mac App Store version because I want the ability to switch licensing types and getting PKGs out for me is painless. I would start using the Mac App Store version ONLY if we started deploying ALL versions of Office as Office 365-licensed and in my case when deploying Mac App Store apps becomes easier than deploying PKGs.

Thank you @blackholemac . That is exactly the answer and detail I was looking for.