Is TubeBuddy for YouTube™ safe?

const TOKEN_SYNC_EVENT = 'tubebuddySyncTokens';
const TOKEN_SYNC_SOURCE = 'tbLabs';
const TOKEN_STORAGE_PREFIX = 'tubebuddyToken-';
const LABS_STATE_REQUEST_EVENT = 'tbLabsStateRequest';
const LABS_STATE_RESPONSE_EVENT = 'tbLabsStateResponse';
const LABS_STATE_KEYS = ['appToExtData', 'LifeCycleDeepLinkData'];
const STUDIO_HOSTNAME = 'studio.youtube.com';
const STUDIO_CHANNEL_STORAGE_KEY = 'activeYouTubeStudioChannel';

function getTokenSyncStorage() {
  if (typeof browser !== 'undefined' && browser.storage && browser.storage.sync) {
    return {
      set: (items) => browser.storage.sync.set(items),
      remove: (keys) => browser.storage.sync.remove(keys),
      get: (keys) => browser.storage.sync.get(keys || null),
    };
  }

  if (typeof chrome !== 'undefined' && chrome.storage && chrome.storage.sync) {
    return {
      set: (items) => new Promise((resolve, reject) => {
        chrome.storage.sync.set(items, () => {
          const err = chrome.runtime && chrome.runtime.lastError;
          if (err) reject(new Error(err.message));
          else resolve();
        });
      }),
      remove: (keys) => new Promise((resolve, reject) => {
        chrome.storage.sync.remove(keys, () => {
          const err = chrome.runtime && chrome.runtime.lastError;
          if (err) reject(new Error(err.message));
          else resolve();
        });
      }),
      get: (keys) => new Promise((resolve, reject) => {
        chrome.storage.sync.get(keys || null, (items) => {
          const err = chrome.runtime && chrome.runtime.lastError;
          if (err) reject(new Error(err.message));
          else resolve(items || {});
        });
      }),
    };
  }

  return null;
}

function isTrustedTokenSyncHost() {
  const host = window.location.hostname || '';
  return host === 'localhost' || host.endsWith('tubebuddy.com') || host.includes('studio.youtube.com');
}

window.addEventListener(LABS_STATE_REQUEST_EVENT, (event) => {
  try {
    if (!isTrustedTokenSyncHost()) return;

    const detail = event && event.detail;
    if (!detail || detail.source !== TOKEN_SYNC_SOURCE) return;

    sendLabsStateSnapshot(detail.reason || 'labs-request', detail.requestId, detail.keys, true);
  } catch (error) {
    window.dispatchEvent(new CustomEvent(LABS_STATE_RESPONSE_EVENT, {
      detail: {
        source: TOKEN_SYNC_SOURCE,
        requestId: event && event.detail ? event.detail.requestId : undefined,
        success: false,
        error: error && error.message ? error.message : 'Unexpected error retrieving extension state',
        studioChannelId: undefined,
        channelId: undefined,
      },
    }));
  }
}, false);

function sendLabsStateSnapshot(reason, requestId, keys, allowNonStudioHost = false) {
  try {
    if (!isTrustedTokenSyncHost()) return;
    if (!allowNonStudioHost && !isStudioHost()) return;

    const storage = getTokenSyncStorage();
    if (!storage || typeof storage.get !== 'function') return;

    const keysToFetch = Array.isArray(keys) && keys.length > 0 ? keys : LABS_STATE_KEYS;

    const snapshotRequestId = requestId || `${reason || 'labs'}-${Date.now()}`;

    const channelKeys = [STUDIO_CHANNEL_STORAGE_KEY];

    storage.get(keysToFetch.concat(channelKeys))
      .then((snapshot) => {
        const channelFromStorage = snapshot ? snapshot[STUDIO_CHANNEL_STORAGE_KEY] : undefined;
        const studioChannelId = typeof channelFromStorage === 'string' ? channelFromStorage.trim() : '';

        if (snapshot && STUDIO_CHANNEL_STORAGE_KEY in snapshot) {
          delete snapshot[STUDIO_CHANNEL_STORAGE_KEY];
        }

        const normalizedStudioChannelId = studioChannelId.length > 0 ? studioChannelId : undefined;

        window.dispatchEvent(new CustomEvent(LABS_STATE_RESPONSE_EVENT, {
          detail: {
            source: TOKEN_SYNC_SOURCE,
            requestId: snapshotRequestId,
            success: true,
            data: snapshot || {},
            reason,
            channelId: normalizedStudioChannelId,
            studioChannelId: normalizedStudioChannelId,
            keys: keysToFetch,
          },
        }));


      })
      .catch((error) => {
        window.dispatchEvent(new CustomEvent(LABS_STATE_RESPONSE_EVENT, {
          detail: {
            source: TOKEN_SYNC_SOURCE,
            requestId: snapshotRequestId,
            success: false,
            error: error && error.message ? error.message : 'Failed to read extension storage',
            reason,
            channelId: undefined,
            studioChannelId: undefined,
            keys: keysToFetch,
          },
        }));


      });
  } catch (error) {
  }
}

var tokenParam = getUrlParameter('t');
var channelParam = getUrlParameter('c');
var redirectParam = getUrlParameter('r');

if (tokenParam) {

    if (tokenParam == 'remove') {

        // When debugging with web-ext change sync to local in line below.
        chrome.storage.sync.remove("tubebuddyToken-" + channelParam, function () { console.log('token removed'); })
    }
    else {
        var dbSaveObject = {};
        dbSaveObject["tubebuddyToken-" + channelParam] = tokenParam;

        // When debugging with web-ext change sync to local in line below.
        chrome.storage.sync.set(dbSaveObject, function () {

            if (redirectParam) {
                var url = '';

                if (window.location.href.indexOf('studio.youtube.com') >= 0) {

                    redirectParam = decodeURIComponent(redirectParam);
                    var poundLocation = redirectParam.indexOf('#');
                    var fullPath = redirectParam.substring(poundLocation);                    
                    if (redirectParam.indexOf('cid=') > 0) {
                        url = redirectParam.substring(0, poundLocation) + '&tbft=1' + fullPath;                        
                    } else {
                         url = 'https://studio.youtube.com/?tbft=1' + fullPath;                        
                   }

                } else {
                    if (redirectParam.indexOf('?') > 0 || redirectParam.indexOf('%3F') > 0 || redirectParam.indexOf('%3f') > 0)
                        url = decodeURIComponent(redirectParam) + '&tbft=1';
                    else
                        url = decodeURIComponent(redirectParam) + '?tbft=1';
                }

                window.location = url;
            }

        });
    }

}

{
  "matches": [
    "https://www.tubebuddy.com/*",
    "https://*.youtube.com/*",
    "http://*.youtube.com/*"
  ],
  "js": [
    "js/webextension-polyfill/browser-polyfill.js",
    "TubeBuddyAppToExt.js"
  ],
  "run_at": "document_start",
  "all_frames": true
}