kernel.js

/**
 * Web3os Kernel
 *
 * @description Entrypoint of the web3os kernel
 * @author Jay Mathis <code@mathis.network>
 * @license MIT
 * @see https://github.com/web3os-org/kernel
 */
/* global Kernel, Terminal, System */
/* global fetch, File, FileReader, localStorage, location, Notification */
'use strict'
import rootPkgJson from '../package.json'
import getConfig from './config'
import AwesomeNotifications from 'awesome-notifications'
import bytes from 'bytes'
import colors from 'ansi-colors'
import columnify from 'columnify'
import CustomEvent from 'custom-event-js'
import figlet from 'figlet'
import figletFont from 'figlet/importable-fonts/Graffiti'
import i18next from 'i18next'
import i18nextBrowserLanguageDetector from 'i18next-browser-languagedetector'
import iconify from '@iconify/iconify'
import Keyboard from 'simple-keyboard'
import path from 'path'
import sweetalert from 'sweetalert2'
import topbar from 'topbar'
import { unzip } from 'unzipit'
import { v4 as uuidv4 } from 'uuid'
import 'systemjs'
import 'animate.css'
import 'awesome-notifications/dist/style.css'
// import 'simple-keyboard/build/css/index.css'
import './css/index.css'
import './themes/default/index.css'
import './themes/default/sweetalert2.css'
import '@material/mwc-button'
import '@material/mwc-icon-button'
import '@material/mwc-snackbar'
import AppWindow from './windows'
import locales from './locales'
import README from '../README.md'
import theme from './themes/default/index.js'
import W3OSTerminal from './terminal'
import { fsModules } from './fs'
let BrowserFS
let memory
const Config = getConfig()
const figletFontName = 'Graffiti'
console.time('web3os:boot')
colors.theme(theme)
globalThis.topbar = topbar
globalThis.global = globalThis.global || globalThis
export let eventsProcessed = 0
export const poweronTime = new Date()
export const bootArgs = new URLSearchParams(globalThis.location.search)
export const isMobile = window.matchMedia('only screen and (max-width: 760px)').matches
export const { name, version } = rootPkgJson
/**
 * References the initialized i18next instance
 * @type {Object}
 * @see https://i18next.com
 */
export const i18n = i18next
const { t } = i18n
i18n.loadAppLocales = locales => {
  for (const [key, data] of Object.entries(locales)) {
    i18n.addResourceBundle(key, 'app', data, true)
    if (data.common) i18n.addResources(key, 'common', data.common, true)
  }
}
export const Web3osTerminal = W3OSTerminal
/**
 * Contains miscellaneous utilities
 * @todo Do this better
 * @type {Object}
 */
export const utils = { bytes, colors, path, wait }
/**
 * Colorize a string to differentiate numbers and letters
 * @param {string} str - The string to colorize
 * @param {Object=} options - Options for colorization
 * @param {Function=} [options.numbers=colors.blue()] - The function to colorize numbers
 * @param {Function=} [options.letters=colors.white()] - The function to colorize letters
 */
utils.colorChars = (str, options = {}) => {
  if (typeof str !== 'string') throw new Error(t('You must provide a string to colorChars'))
  const numbers = options.numbers || colors.blue
  const letters = options.letters || colors.white
  return str.split('').map(c => isNaN(c) ? letters(c) : numbers(c)).join('')
}
/**
 * Contains all registered kernel modules
 * @type {Object}
 */
export const modules = {}
/**
 * Contains all registered kernel intervals
 * @type {Object}
 */
export const intervals = {}
/**
 * References the @iconify/iconify library
 */
export const icons = iconify
/**
 * Create an icon element
 * 
 * @param {string} id - The @iconify/iconify icon identifier
 * @param {Array.<string>} classes - Array of additional classes to apply to the element
 * @returns {HTMLElement}
 */
export const createIcon = (id, classes) => {
  const icon = document.createElement('i')
  icon.classList.add(...classes)
  icon.dataset.icon = id
  return icon
}
/**
 * Gives access to the virtual keyboard
 * 
 * This gives us more control and consistency over mobile input
 * 
 * @type {SimpleKeyboard}
 * @see https://virtual-keyboard.js.org
 */
export let keyboard
/**
 * Gives access to the BrowserFS API
 * @type {Object}
 */
export let fs
/**
 * The main kernel event bus
 * 
 * @type {CustomEvent}
 * 
 * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent
 * @see https://www.npmjs.com/package/custom-event-js
 * 
 * @property {Function} dispatch - Dispatch an event
 * @property {string} dispatch.eventName - The name of the event
 * @property {Object} dispatch.detail - The event detail payload
 * @property {Function} on - Subscribe to event
 * @property {string} on.eventName - The name of the event
 * @property {Function} on.callback - Execute when this event is triggered
 * @property {Function} off - Unsubscribe from event
 * @property {string} off.eventName - The name of the event
 * @property {Function} off.callback - Execute when this event is triggered
 */
export const events = CustomEvent
/**
 * The list of kernel events
 */
export const KernelEvents = Config.kernelEvents
/**
 * The primary Broadcast Channel for web3os
 * 
 * @type {BroadcastChannel}
 * @see https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API
 */
export const broadcast = new BroadcastChannel('web3os')
broadcast.onmessage = msg => {
  console.log('Incoming Broadcast:', msg)
}
/**
 * Send an analytics event to the analytics endpoint
 */
export async function analyticsEvent ({ event, user, details, severity }) {
  if (/^localhost/.test(location.host)) return
  if (get('config', 'analytics-opt-out')) return
  if (!user && !get('user', 'uuid')) set('user', 'uuid', uuidv4())
  user = user || get('user', 'uuid')
  const analyticsEndpoint = get('config', 'analytics-endpoint') || Config.analyticsEndpoint
  if (!analyticsEndpoint) return
  await fetch(analyticsEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ event: event || 'log', severity: severity || 'INFO', user, details: details || {} })
  })
}
/**
 * Output system information
 */
export async function printSystemInfo () {
  const isSmall = window.innerWidth <= 445
  let output = ''
  // if (navigator.deviceMemory) output += `\n${colors.info('RAM:')} >= ${colors.muted(navigator.deviceMemory + 'GB')}\n`
  if (navigator.userAgentData) {
    const { brand, version } = navigator.userAgentData.brands.slice(-1)?.[0]
    const browser = `${brand} v${version}`
    output += `${colors.info(`${t('Host')}:    `)}\t${location.host}\n`
    output += `${colors.info(`${t('Platform')}:`)}\t${navigator.userAgentData.platform || t('Unknown')}\n`
    output += `${colors.info(`${t('Browser')}:`)}\t${browser}\n`
  }
  if (navigator.getBattery) {
    const batt = await navigator.getBattery()
    batt.addEventListener('chargingchange', () => {
      if (batt.charging && !get('config', 'battery-no-charge-confetti')) execute('confetti')
    })
    output += `${colors.info(`${t('Battery')}:`)}\t${batt.charging ? `${batt.level * 100}% ⚡` : `${batt.level * 100}% 🔋`}\n`
  }
  if (navigator.storage?.estimate) {
    const storageDetails = await navigator.storage.estimate()
    const used = bytes(storageDetails.usage)
    const free = bytes(storageDetails.quota - storageDetails.usage)
    output += `${colors.info(`${t('Storage')}:`)}\t${used} ${isSmall ? '\n\t ' : '/'} ${free}\n`
  }
  if (console.memory) output += `${colors.info(t('Heap Limit') + ':')}\t${bytes(console.memory.jsHeapSizeLimit)}\n`
  if (navigator.hardwareConcurrency) output += `${colors.info(t('Cores') + ':')}\t\t${navigator.hardwareConcurrency}\n`
  if (typeof navigator.onLine === 'boolean') output += `${colors.info(t('Online') + ':')}\t\t${navigator.onLine ? t('Yes') : t('No')}\n`
  if (navigator.connection) output += `${colors.info(t('Downlink') + ':')}\t~${navigator.connection.downlink} Mbps\n`
  log(output)
  return output
}
/**
 * Output the boot introduction
 * */
export async function printBootIntro () {
  const isSmall = window.innerWidth <= 445
  log(colors.info(`${t('kernel:bootIntroSubtitle', '\t     https://web3os.sh')}`))
  log(colors.heading.success.bold(`\n${isSmall ? '' : '\t '}  web3os kernel v${rootPkgJson.version}   `))
  log(colors.warning(`${isSmall ? '' : '\t '}⚠         BETA         ⚠\n`))
  await printSystemInfo()
  if (!localStorage.getItem('web3os_first_boot_complete')) {
    log(colors.danger(`\n⚠ ${t('kernel:firstBootWarning', 'The first boot will take the longest, please be patient!')} ⚠\n`))
  }
  if (navigator.userAgentData?.platform === 'Android' || navigator.userAgentData?.platform === 'iPhone' || window.innerWidth < 500 || window.innerHeight < 500) {
    log(colors.danger(`\n⚠ 🐉  ${t('kernel:mobileExperienceWarning', 'NOTE: The mobile experience is pretty wacky and experimental - proceed with caution!')} ⚠`))
  }
  log(colors.underline(t('A few examples') + ':'))
  log(colors.danger(`\n${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:help', 'help'))} ${t('kernel:bootIntro.help', 'for help')}`))
  log(colors.gray(`${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:docs', 'docs'))} ${t('kernel:bootIntro.docs', 'to open the documentation')}`))
  log(colors.info(`${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:desktop', 'desktop'))} ${t('kernel:bootIntro.desktop', 'to launch the desktop')}`))
  // log(colors.primary(`${t('typeVerb', 'Type')} ${colors.bold.underline('wallet connect')} ${t('kernel:bootIntro.wallet', 'to connect your wallet')}`))
  log(colors.success(`${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:files /bin', 'files /bin'))} ${t('kernel:bootIntro.filesBin', 'to explore all executable commands')}`))
  // log(colors.warning(`${t('typeVerb', 'Type')} ${colors.bold.underline('lsmod')} ${t('kernel:bootIntro.lsmod', 'to list all kernel modules')}`))
  log(colors.muted(`${t('typeVerb', 'Type')} ${colors.bold.underline(`clip <${t('Command')}>`)} ${t('kernel:bootIntro.clip', 'to copy the output of a command to the clipboard')}`))
  // log(colors.white(`${t('typeVerb', 'Type')} ${colors.bold.underline('repl')} ${t('kernel:bootIntro.repl', 'to run the interactive Javascript terminal')}`))
  log(colors.cyan(`${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:confetti', 'confetti'))} ${t('kernel:bootIntro.confetti', 'to fire the confetti gun 🎉')}`))
  // log(colors.magenta(`${t('typeVerb', 'Type')} ${colors.bold.underline('minipaint')} ${t('kernel:bootIntro.minipaint', 'to draw Art™ 🎨')}`))
  if (bootArgs.get('source') !== 'pwa') {
    isSmall ? log('\n-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-') : log('\n-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-')
    log(colors.success(`${t('typeVerb', 'Type')} ${colors.bold.underline(Terminal.createSpecialLink('web3os:execute:install', 'install'))} ${t('kernel:bootIntro.install', 'to install web3os to your device')}`))
    isSmall ? log('-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-') : log('-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-')
  }
  log('\nhttps://docs.web3os.sh')
  log('https://github.com/web3os-org')
  log(colors.muted(`\n${t('Booting')}...`))
}
/**
 * Write the kernel memory to localStorage
 */
export function updateLocalStorage () { localStorage.setItem('memory', JSON.stringify(memory)) }
/**
 * Restore the kernel memory from localStorage
 */
export function loadLocalStorage () {
  try {
    const storedMemory = localStorage.getItem('memory')
    memory = storedMemory ? JSON.parse(storedMemory) : { firstBootVersion: rootPkgJson.version }
    updateLocalStorage()
  } catch (err) {
    console.error(err)
    log(t('Failed to load memory from local storage'))
    memory = {}
  }
  console.assert(typeof memory === 'object', t('Failed to load memory from local storage'))
}
/**
 * Set a value in the kernel memory object
 * @param {!string} namespace - The namespace in which to set the value
 * @param {!string} key - The key in which to set the value
 * @param {!any} value - The value to set
 */
export function set (namespace, key, value) {
  if (!namespace || namespace === '') throw new Error(t('Invalid namespace'))
  if (!key || key === '') throw new Error(t('Invalid key'))
  if (!value || value === '') throw new Error(t('Invalid value'))
  memory[namespace] = memory[namespace] || {}
  memory[namespace][key] = value
  updateLocalStorage()
  return memory[namespace]?.[key]
}
/**
 * Get a value from the kernel memory object
 * @param {!string} namespace - The namespace from which to get the value
 * @param {?string} key - The key to retrieve, or undefined to get entire namespace
 */
export function get (namespace, key) {
  if (!key) return memory[namespace] || null
  return memory[namespace]?.[key] || null
}
/**
 * Dump the kernel memory to a JSON object
 * @returns {string} dump The memory dump
 */
export function dump () { return JSON.stringify(memory) }
/**
 * Restore the kernel memory from a JSON object
 * @param {!string} json - The JSON object generated from dump()
 */
export function restore (json) {
  memory = JSON.parse(json)
  updateLocalStorage()
  return memory
}
/**
 * Delete the specified key from the kernel memory object
 * @param {!string} namespace - The namespace containing the key
 * @param {!key} key - The key to delete
 */
export function deleteKey (namespace, key) {
  if (!memory[namespace]?.[key]) throw new Error(t('Invalid namespace or key'))
  delete memory[namespace][key]
  updateLocalStorage()
}
/**
 * Delete the specified namespace from the kernel memory object
 * @param {!namespace} namespace - The namespace to delete
 */
export function deleteNamespace (namespace) {
  if (!memory[namespace]) throw new Error(t('Invalid namespace'))
  delete memory[namespace]
  updateLocalStorage()
}
/**
 * Log a message to the terminal
 * @param {!any} message - The message or object to log
 * @param {?Object} options - Logging options
 * @param {Boolean=} [options.console=true] - Enable logging to both browser console and Terminal
 * @param {?Web3osTerminal} options.terminal - The terminal to attach to, or undefined for global Terminal
 */
export function log (message, options = { console: true }) {
  if (!message) return
  message = message.replace(/\\n/gm, '\n')
  if (options.console) console.log(message)
  const term = options.terminal || globalThis.Terminal
  term.log(message)
}
/**
 * Manages interactions with the windowing system
 * @type Object
 * @property {Set} _collection - The collection of windows
 *
 * @property {Function} create - Create a new window
 * @property {Object} create.options - Options to pass to WinBox
 *
 * @property {Function} find - Find a window by ID
 * @property {string} find.id - The ID of the window (usually winbox-#; stored on app.window.id)
 * 
 * @see https://nextapps-de.github.io/winbox/
 */
export const windows = {
  _collection: new Set(),
  create: options => {
    const app = new AppWindow(options)
    windows._collection.add(app)
    return app
  },
  find: id => {
    return Array.from(windows._collection.values()).find(app => app.window.id === id)
  }
}
/**
 * Show a SweetAlert dialog
 * @async
 * @param {Object} options - SweetAlert2 options
 * @returns {SweetAlertDialog}
 */
export async function dialog (options = {}) {
  return sweetalert.fire({
    heightAuto: false,
    denyButtonColor: 'red',
    confirmButtonColor: 'green',
    customClass: { container: 'web3os-kernel-dialog-container' },
    ...options
  })
}
/**
 * Execute a command
 * @async
 * @param {string} cmd - The command to execute
 * @returns {CommandResult}
 */
export async function execute (cmd, options = {}) {
  const exec = cmd.split(' ')[0]
  const term = options.terminal || globalThis.Terminal
  let command = term.aliases[exec] ? modules[term.aliases[exec]] : modules[exec]
  if (options.topbar) topbar.show()
  if (!command) {
    try {
      if (fs.existsSync(exec)) {
        const data = JSON.parse(fs.readFileSync(exec).toString())
        command = modules[data?.name]
      } else {
        command = await import(`./modules/${exec}`)
      }
    } catch (err) {
      console.error(err)
    }
  }
  options.doPrompt = options.doPrompt || false
  if (options.topbar) topbar.hide()
  if (!command?.run) {
    term.log(colors.danger(`Invalid command; try ${Terminal.createSpecialLink('web3os:execute:help', colors.white('help'))} or ${Terminal.createSpecialLink(`web3os:execute:3pm install ${exec}`, colors.blue(`3pm install ${exec}`))}`))
    navigator.vibrate([200, 50, 200])
    return term.prompt()
  }
  try {
    if (options.topbar) topbar.show()
    const args = cmd.split(' ').slice(1).join(' ')
    const result = await command.run(term, args)
    if (options.topbar) topbar.hide()
    if (options.doPrompt) term.prompt()
    return result
  } catch (err) {
    navigator.vibrate([200, 50, 200])
    console.error(command, err)
    if (err) term.log(err.message || 'An unknown error occurred')
    if (options.doPrompt) term.prompt()
    throw err
  }
}
/**
 * Execute a script file
 * @async
 * @param {string} path - The path of the script
 * @returns {SweetAlertDialog}
 */
export async function executeScript (filename, options = {}) {
  const term = options.terminal || globalThis.Terminal
  if (!filename || filename === '') return term.log(colors.danger('Invalid filename'))
  filename = utils.path.resolve(term.cwd, filename)
  const value = fs.readFileSync(filename, 'utf8')
  const commands = value.split('\n').map(c => c.trim())
  for (const cmd of commands) {
    if (cmd?.trim().length > 0 && cmd?.[0] !== '#' && cmd?.substr(0, 2) !== '//') await execute(cmd, { terminal: term, doPrompt: false })
  }
}
/**
 * Execute the /config/autostart.sh script
 * @async
 * @param {string=} defaultAutoStart - Write autostart script with this content if it doesn't exist
 */
export async function autostart (defaultAutoStart) {
  try {
    if (defaultAutoStart && !fs.existsSync('/config/autostart.sh')) {
      fs.writeFileSync('/config/autostart.sh', defaultAutoStart) // Setup default autostart.sh
    }
    if (fs.existsSync('/config/autostart.sh')) await executeScript('/config/autostart.sh')
  } catch (err) {
    console.error(err)
    log(colors.danger('Failed to complete autostart script'))
  } finally {
    globalThis.Terminal.prompt()
  }
}
/**
 * Send an awesome-notification
 * @type {AwesomeNotifications}
 * @todo awesome-notifications will likely eventually replace sweetalert
 * @see https://f3oall.github.io/awesome-notifications
 */
export const notify = new AwesomeNotifications({
  position: 'top-right',
  icons: {
    enabled: true,
    prefix: '<i class="iconify" data-icon="fa6-regular:',
    suffix: '" />'
  }
})
/**
 * Send a browser/platform notification
 * @async
 * @param {Object=} options - The notification options (Notification API)
 * @see https://developer.mozilla.org/en-US/docs/Web/API/notification
 */
export async function systemNotify (options = {}) {
  if (Notification.permission !== 'granted') throw new Error('Notification permission denied')
  try {
    const notification = new Notification(options.title, options)
  } catch (err) {
    console.warn(err)
    navigator.serviceWorker.ready.then(registration => {
      registration.showNotification('Notification with ServiceWorker')
    })
  }
}
/**
 * Show a snackbar notification
 * 
 * @deprecated
 * This can still be useful I think, but it's being deprecated
 * in favor of awesome-notifications. Should this be removed?
 * 
 * @async
 * @param {Object=} options - The snackbar options
 * @see https://www.npmjs.com/package/@material/mwc-snackbar
 */
export async function snackbar (options = {}) {
  const snack = document.createElement('mwc-snackbar')
  snack.id = options.id || 'snack-' + Math.random()
  snack.leading = options.leading || false
  snack.closeOnEscape || false
  snack.labelText = options.labelText || ''
  snack.stacked = options.stacked || false
  const closeButton = document.createElement('mwc-icon-button')
  closeButton.icon = 'close'
  closeButton.slot = 'dismiss'
  snack.appendChild(closeButton)
  document.body.appendChild(snack)
  snack.show()
}
/**
 * Sets up the filesystem
 * 
 * These parameters can also be provided as a query parameter:
 * 
 * https://web3os.sh/?initfsUrl=https://my.place.com/initfs.zip
 * 
 * Bare minimum, temporary, fs:
 * https://web3os.sh/?mountableFilesystemConfig={ "/": { "fs": "InMemory" }, "/bin": { "fs": "InMemory" } }
 * 
 * @async
 * @param {string=} initfsUrl - URL to a zipped filesystem snapshot
 * @param {MountableFileSystemOptions=} mountableFilesystemConfig - Filesystem configuration object for BrowserFS
 * @see https://jvilk.com/browserfs/2.0.0-beta/index.html
 */
export async function setupFilesystem (initfsUrl, mountableFilesystemConfig) {
  return new Promise(async (resolve, reject) => {
    const browserfs = await import('browserfs')
    const filesystem = {}
  
    let initfs
    initfsUrl = initfsUrl || bootArgs.get('initfsUrl')
    mountableFilesystemConfig = bootArgs.get('mountableFilesystemConfig')
      ? JSON.parse(bootArgs.get('mountableFilesystemConfig')) : Config.defaultFilesystemOverlayConfig
  
    if (bootArgs.has('initfsUrl')) {
      try {
        const result = await dialog({
          title: 'Use initfs?',
          icon: 'warning',
          allowOutsideClick: false,
          allowEscapeKey: false,
          showDenyButton: true,
          showLoaderOnConfirm: true,
          focusDeny: true,
          confirmButtonText: 'Yes',
          html: `
            <p>Do you want to overwrite existing files in your filesystem with the initfs located at:</p>
            <h4><a href="${initfsUrl}" target="_blank">${initfsUrl}</a></h4>
            <p><strong>Be sure you trust the source!</strong></p>
          `,
          preConfirm: async () => {
            try {
              return await unzip(initfsUrl)
            } catch (err) {
              console.error(err)
              globalThis.Terminal?.log(colors.danger(`Failed to unzip initfsUrl at ${initfsUrl}`))
              return true
            }
          }
        })
  
        if (result.isDenied) throw new Error('User rejected using initfs')
        const { entries } = result.value
        initfs = entries
        globalThis.history.replaceState(null, null, '/') // prevent reload with initfs
      } catch (err) {
        globalThis.Terminal?.log(colors.danger('Failed to unzip initfsUrl ' + initfsUrl))
        globalThis.Terminal?.log(colors.danger(err.message))
        console.error(err)
      }
    }
    /**
     * Add HTML5FS
     * @todo Broken on Firefox
     * @see: webkitStorageOptions
     */
    if (!navigator.userAgent.includes('Firefox')) {
      mountableFilesystemConfig['/mount/html5fs'] = {
        fs: 'AsyncMirror',
        options: {
          sync: { fs: 'InMemory' },
          async: {
            fs: 'HTML5FS',
            options: {}
          }
        }
      }
    }
  
    browserfs.install(filesystem)
    browserfs.configure({
      fs: 'MountableFileSystem',
      options: mountableFilesystemConfig
    }, err => {
      if (err) {
        console.error(err)
        log(colors.danger(`Failed to initialize filesystem: ${err.message}`))
      } else {
        BrowserFS = filesystem
        fs = filesystem.require('fs')
  
        // Use an initfs if available
        if (initfs) {
          Object.entries(initfs).forEach(async ([name, entry]) => {
            const filepath = utils.path.join('/', name)
  
            if (entry.isDirectory) !fs.existsSync(filepath) && fs.mkdirSync(utils.path.join('/', name))
            else {
              const parentDir = utils.path.parse(filepath).dir
              if (!fs.existsSync(parentDir)) fs.mkdirSync(parentDir)
              fs.writeFileSync(filepath, BrowserFS.Buffer.from(await entry.arrayBuffer()))
            }
          })
        }
  
        // Prepare required paths for packages
        const defaultPackages = bootArgs.get('defaultPackages') || Config.defaultPackages || []
        if (!fs.existsSync('/var')) fs.mkdirSync('/var')
        if (!fs.existsSync('/var/packages')) fs.mkdirSync('/var/packages')
        if (!fs.existsSync('/config')) fs.mkdirSync('/config')
        if (!fs.existsSync('/config/packages')) fs.writeFileSync('/config/packages', JSON.stringify(bootArgs.has('noDefaultPackages') ? [] : defaultPackages))
        // Populate initial procfs
        // TODO: Make procfs separate module and self-updating
        fs.writeFileSync('/proc/host', location.host)
        fs.writeFileSync('/proc/version', rootPkgJson.version)
        fs.writeFileSync('/proc/platform', navigator.userAgentData.platform)
        fs.writeFileSync('/proc/querystring', location.search)
        fs.writeFileSync('/proc/language', navigator.language)
        fs.writeFileSync('/proc/user-agent', navigator.userAgent)
        fs.writeFileSync('/proc/user-agent.json', JSON.stringify(navigator.userAgentData, null, 2))
        
        try {
          const { downlink, effectiveType, rtt, saveData } = navigator.connection
          fs.writeFileSync('/proc/connection', JSON.stringify({ downlink, effectiveType, rtt, saveData }, null, 2))
        } catch {}
        // Drag and drop on terminal
        // const dragenter = e => { e.stopPropagation(); e.preventDefault() }
        // const dragover = e => { e.stopPropagation(); e.preventDefault() }
        // const drop = e => {
        //   e.stopPropagation()
        //   e.preventDefault()
        //   const dt = e.dataTransfer
        //   const files = dt.files
  
        //   for (const file of files) {
        //     const reader = new FileReader()
  
        //     reader.readAsArrayBuffer(file)
        //     reader.onload = () => {
        //       const buffer = BrowserFS.Buffer.from(reader.result)
        //       const filepath = utils.path.resolve(Terminal.cwd, file.name)
        //       fs.writeFileSync(filepath, buffer)
        //       snackbar({ labelText: `Uploaded ${filepath}` })
        //     }
        //   }
        // }
  
        // Terminal.addEventListener('dragenter', dragenter)
        // Terminal.addEventListener('dragover', dragover)
        // Terminal.addEventListener('drop', drop)
        resolve(fs)
      }
    })
    
  })
}
/**
 * Load the kernel's core internal commands
 * 
 * @todo These are here because they're relatively simple, but many of them should be
 * moved to their own respective external modules.
 * 
 * @async
 */
async function registerKernelBins () {
  const { t } = Kernel.i18n
  const kernelBins = {}
  kernelBins.alert = { description: t('kernel:bins.descriptions.alert', 'Show an alert'), run: (term, context) => dialog({ text: context }) }
  kernelBins.clear = { description: t('kernel:bins.descriptions.clear', 'Clear the terminal'), run: term => term.clear() }
  kernelBins.date = { description: t('kernel:bins.descriptions.date', 'Display the date/time'), run: term => term.log(new Intl.DateTimeFormat(Kernel.i18n.language || 'en-US', { dateStyle: 'long', timeStyle: 'short' }).format(new Date()))}
  kernelBins.docs = { description: t('kernel:bins.descriptions.docs', 'Open the documentation'), run: term => { modules.www.run(term, '--title "Web3os Documentation" --no-toolbar /docs') }}
  kernelBins.dump = { description: t('kernel:bins.descriptions.dump', 'Dump the memory state'), run: term => term.log(dump()) }
  kernelBins.echo = { description: t('kernel:bins.descriptions.echo', 'Echo some text to the terminal'), run: (term, context) => term.log(context) }
  kernelBins.history = { description: t('kernel:bins.descriptions.history', 'Show command history'), run: term => { return term.log(JSON.stringify(term.history)) } }
  kernelBins.import = { description: t('kernel:bins.descriptions.import', 'Import a module from a URL'), run: async (term, context) => await importModuleUrl(context) }
  kernelBins.man = { description: t('kernel:bins.descriptions.man', 'Alias of help'), run: (term, context) => modules.help.run(term, context) }
  kernelBins.sh = { description: t('kernel:bins.descriptions.sh', 'Execute a web3os script'), run: (term, context) => executeScript(context, { terminal: term }) }
  kernelBins.systeminfo = { description: t('kernel:bins.descriptions.systeminfo', 'Print system information'), run: async () => await printSystemInfo() }
  kernelBins.systemnotify = { description: t('kernel:bins.descriptions.systemnotify', 'Show a browser/platform notification; e.g., systemnotify Title Body'), run: (term, context) => systemNotify({ title: context.split(' ')[0], body: context.split(' ')[1] }) }
  kernelBins.reboot = { description: t('kernel:bins.descriptions.reboot', 'Reload web3os'), run: () => location.reload() }
  kernelBins.restore = { description: t('kernel:bins.descriptions.restore', 'Restore the memory state'), run: (term, context) => restore(context) }
  kernelBins.snackbar = { description: t('kernel:bins.descriptions.snackbar', 'Show a snackbar; e.g. snackbar Alert!'), run: (term, context) => snackbar({ labelText: context }) }
  kernelBins.wait = { description: t('kernel:bins.descriptions.wait', 'Wait for the specified number of milliseconds'), run: (term, context) => wait(context) }
  kernelBins.alias = {
    description: t('kernel:bins.descriptions.alias', 'Set or list command aliases'),
    help: `${t('Usage')}: alias [src] [dest]`,
    run: (term, context) => {
      if (!context || context === '') return term.log(term.aliases)
      const command = context.split(' ')
      if (command.length !== 2) throw new Error('You must specify the src and dest commands')
      term.aliases[command[0]] = command[1]
    }
  }
  kernelBins.ipecho = {
    description: t('kernel:bins.descriptions.ipecho', 'Echo your public IP address'),
    run: async (term = globalThis.Terminal) => {
      const endpoint = get('config', 'ipecho-endpoint') || Config.ipechoEndpoint || 'https://ipecho.net/plain'
      const result = await fetch(endpoint)
      const ip = await result.text()
      console.log({ ip })
      term.log(ip)
      return ip
    }
  }
  kernelBins.lsmod = {
    description: t('kernel:bins.descriptions.lsmod', 'List loaded kernel modules'),
    run: async (term = globalThis.Terminal) => {
      let mods = { ...modules }
      // This is useless right now, but in the future it may help us transition to other environments:
      if (module?.exports) mods = { ...mods, ...module.exports }
      const sortedMods = Object.keys(mods).sort()
      term.log(sortedMods)
      return sortedMods
    }
  }
  kernelBins.memoryinfo = {
    description: `${t('kernel:bins.descriptions.memoryinfo', 'Show Javascript heap information')}`,
    run: async (term = globalThis.Terminal) => {
      const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = console.memory
      const meminfo = {
        jsHeapSizeLimit: bytes(jsHeapSizeLimit),
        totalJSHeapSize: bytes(totalJSHeapSize),
        usedJSHeapSize: bytes(usedJSHeapSize)
      }
      term.log(meminfo)
      return meminfo
    }
  }
  kernelBins.open = {
    description: `${t('kernel:bins.descriptions.open', 'Open a shortcut defined in /config/shortcuts')}`,
    run: async (term = globalThis.Terminal, context) => {
      if (!fs.existsSync('/config/shortcuts')) throw new Error('/config/shortcuts does not exist')
      const shortcuts = JSON.parse(fs.readFileSync('/config/shortcuts', 'utf8'))
      if (!context || context === '') return term.log(JSON.stringify(shortcuts, null, 2))
      if (!shortcuts[context]) throw new Error('Invalid shortcut')
      const shortcut = shortcuts[context]
      switch (shortcut.type) {
        case 'execute':
          const cmds = shortcut.target.split(';').map(cmd => cmd.trim())
          for await (const cmd of cmds) term.kernel.execute(cmd)
          break
        case 'url':
          return window.open(shortcut.target, '_blank')
      }
    }
  }
  kernelBins.storageinfo = {
    description: t('kernel:bins.descriptions.storage', 'Display storage usage information'),
    run: async (term = globalThis.Terminal) => {
      const rawData = await navigator.storage.estimate()
      const data = {
        quota: bytes(rawData.quota),
        usage: bytes(rawData.usage),
        usageDetails: {}
      }
      Object.entries(rawData.usageDetails).forEach(entry => {
        data.usageDetails[entry[0]] = bytes(entry[1])
      })
      term.log(data)
      return data
    }
  }
  kernelBins.set = {
    description: t('kernel:bins.descriptions.set', 'Set a kernel memory value'),
    help: `${t('Usage')}: set <namespace> <key> <value>`,
    run: (term, context = '') => {
      const parts = context.split(' ')
      const namespace = parts[0]
      const key = parts[1]
      const value = parts.slice(2, parts.length).join(' ')
      term.log(set(namespace, key, value))
    }
  }
  kernelBins.get = {
    description: t('kernel:bins.descriptions.get', 'Get a kernel memory namespace or key'),
    help: `${t('Usage')}: get <namespace> [key]`,
    run: (term, context = '') => {
      const parts = context.split(' ')
      const namespace = parts[0]
      const key = parts[1]
      const result = get(namespace, key)
      term.log(typeof result === 'string' ? result : JSON.stringify(result))
    }
  }
  kernelBins.unset = {
    description: t('kernel:bins.descriptions.unset', 'Delete specified memory namespace or key'),
    help: `${t('Usage')}: unset <namespace> [key]`,
    run: (term, context = '') => {
      try {
        const parts = context.split(' ')
        if (parts[1]) deleteKey(parts[0], parts[1])
        else deleteNamespace(parts[0])
      } catch (err) {
        console.error(err)
        term.log(colors.danger(err.message))
      }
    }
  }
  kernelBins.eval = {
    description: t('kernel:bins.descriptions.eval', 'Load and evaluate a Javascript file'),
    run: (term, context) => {
      if (!context || context === '') return term.log(colors.danger('Invalid filename'))
      const filename = utils.path.resolve(term.cwd, context)
      if (fs.existsSync(filename)) {
        const code = fs.readFileSync(filename, 'utf-8')
        eval(code) // eslint-disable-line
      } else {
        eval(context)
      }
    }
  }
  kernelBins.clip = {
    description: t('kernel:bins.descriptions.clip', 'Copy return value of command to clipboard'),
    help: `${t('Usage')}: clip <command>`,
    run: async (term, context) => {
      if (!context || context === '') return
      const parts = context.split(' ')
      const mod = modules[parts[0]]
      let result = await mod.run(term, parts.splice(1).join(' '))
      if (Array.isArray(result) && result.length === 1) result = result[0] 
      return await navigator.clipboard.writeText(typeof result === 'string' ? result : JSON.stringify(result, null, 2))
    }
  }
  kernelBins.height = {
    description: t('kernel:bins.descriptions.height', 'Set body height'),
    run: (term, context) => { document.body.style.height = context }
  }
  kernelBins.width = {
    description: t('kernel:bins.descriptions.width', 'Set body width'),
    run: (term, context) => { document.body.style.width = context }
  }
  kernelBins.objectUrl = {
    description: t('kernel:bins.descriptions.objectUrl', 'Create an ObjectURL for a file'),
    run: (term, filename) => {
      const { t } = Kernel.i18n
      if (!filename || filename === '') throw new Error(t('invalidFilename', 'Invalid filename'))
      const data = fs.readFileSync(utils.path.join(term.cwd, filename))
      const file = new File([data], utils.path.parse(filename).base, { type: 'application/octet-stream' })
      const url = URL.createObjectURL(file)
      term.log(url)
      return url
    }
  }
  kernelBins.geo = {
    description: t('kernel:bins.descriptions.geo', 'Geolocation Utility'),
    run: async (term = globalThis.Terminal) => {
      if (!navigator.geolocation) throw new Error(t('kernel:bins.errors.geo.geolocationUnavailable', 'Geolocation is not available'))
      return new Promise((resolve, reject) => {
        try {
          navigator.geolocation.getCurrentPosition(pos => {
            const { latitude, longitude } = pos.coords
            const link = `https://www.openstreetmap.org/search?query=${latitude}%2C${longitude}`
            term.log({ latitude, longitude, link, pos })
            resolve({ latitude, longitude, link, pos })
          })
        } catch (err) {
          console.error(err)
          if (err.message) term.log(colors.danger(err.message))
          reject(err)
        }
      })
    }
  }
  kernelBins.eyedropper = {
    description: t('kernel:bins.descriptions.eyeDropper', 'Pick colors using the eyedropper'),
    run: async (term = globalThis.Terminal) => {
      const dropper = new EyeDropper()
      const color = await dropper.open()
      term.log(color)
      return color
    }
  }
  for (const [name, mod] of Object.entries(kernelBins)) {
    loadModule(mod, { name: `@web3os-core/${name}` })
  }
}
/**
 * Load the kernel's core external modules
 * @async
 */
async function registerBuiltinModules () {
  const mods = process.env.BUILTIN_MODULES ? process.env.BUILTIN_MODULES.split(',') : (Config.builtinModules || [])
  for (const mod of mods) {
    try {
      const modBin = await import(`./modules/${mod}`)
      await loadModule(modBin, { name: `@web3os-core/${mod}` })
    } catch (err) {
      console.error(err)
      Terminal.log(colors.danger(`Error loading module: ${mod}`))
      Terminal.log(err.message)
    }
  }
}
/**
 * Load a module into the kernel
 * @async
 * @param {!ModInfo} mod - The mod to load
 * @param {Object=} options - Options for loading the module
 */
export async function loadModule (mod, options = {}) {
  const { t } = Kernel.i18n
  if (!mod) throw new Error(`${t('kernel:invalidModule', 'Invalid module provided to')} kernel.loadModule`)
  let { description, help, name, run, version, pkgJson } = options
  description = description || mod.description
  version = version || pkgJson?.version || mod.version
  help = help || mod.help || t('kernel:helpNotExported', 'Help is not exported from this module')
  name = name || mod.name || 'module_' + Math.random().toString(36).slice(2)
  run = run || mod.run || mod.default
  if (!modules[name]) modules[name] = {}
  modules[name] = { ...modules[name], ...mod, run, name, version, description, help }
  const web3osData = pkgJson?.web3osData
  const modInfo = {
    name,
    version,
    description,
    web3osData,
    help
  }
  if (run) {
    let modBin
    if (name.includes('/')) {
      modBin = utils.path.join('/bin', name.split('/')[0], name.split('/')[1])
      if (!fs.existsSync(`/bin/${name.split('/')[0]}`)) fs.mkdirSync(`/bin/${name.split('/')[0]}`)
    } else {
      modBin = utils.path.join('/bin', name)
    }
    fs.writeFileSync(modBin, JSON.stringify(modInfo, null, 2))
  }
  events.dispatch('ModuleLoaded', { modInfo })
}
/**
 * Directly import an ES module from a URL
 * @async
 * @param {string} url - The URL of the module to import
 * @return {Module}
 */
export async function importModuleUrl (url) {
  return await import(/* webpackIgnore: true */ url)
}
/**
 * Directly import a UMD module from a URL
 * @async
 * @param {string} url - The URL of the module to import
 * @return {Module}
 */
export async function importUMDModule (url, name, module = { exports: {} }) {
  // Dark magic stolen from a lost tome of stackoverflow
  const mod = (Function('module', 'exports', await (await fetch(url)).text())
    .call(module, module, module.exports), module).exports
  mod.default = mod.default || mod
  return mod
}
/**
 * Load or install the packages defined in /config/packages
 * @async
 */
export async function loadPackages () {
  const tasks = []
  const packages = JSON.parse(fs.readFileSync('/config/packages').toString())
  for (const pkg of packages) {
    tasks.push(new Promise(async (resolve, reject) => {
      try {
        if (/^(http|ftp).*\:/i.test(pkg)) {
          if (modules?.['3pm']) {
            await modules['3pm'].install(pkg, { warn: false })
          } else {
            const waitFor3pm = async () => {
              if (!modules?.['3pm']) return setTimeout(waitFor3pm, 500)
              await modules['3pm'].install(pkg, { warn: false })
            }
            await waitFor3pm()
          }
          return resolve()
        }
        const pkgJson = JSON.parse(fs.readFileSync(`/var/packages/${pkg}/package.json`))
        const main = pkgJson.web3osData.main || pkgJson.main || 'index.js'
        const type = pkgJson.web3osData.type || 'es'
        const mainUrl = `${pkgJson.web3osData.url}/${main}`
        const mod = type === 'umd'
          ? await importUMDModule(mainUrl)
          : await importModuleUrl(mainUrl)
        await loadModule(mod, pkgJson)
        resolve()
      } catch (err) {
        console.error(err)
        globalThis.Terminal.log(colors.danger(err.message))
        reject(err)
      }
    }))
  }
  await Promise.all(tasks)
}
/**
 * Show the boot splash screen
 * @async
 * @todo Make this more customizable
 * @param {string} msg - The message to display
 * @param {Object=} options - The splash screen options
 */
export async function showSplash (msg, options = {}) {
  const { t } = Kernel.i18n
  document.querySelector('#web3os-splash')?.remove()
  // TODO: Migrating everything to iconify
  const icon = document.createElement('mwc-icon')
  icon.id = 'web3os-splash-icon'
  icon.style.color = options.iconColor || '#03A062'
  icon.style.fontSize = options.iconFontSize || '10em'
  icon.style.marginTop = '2rem'
  icon.innerText = options.icon || 'hourglass_empty'
  if (!options.disableAnimation) icon.classList.add('animate__animated', 'animate__zoomIn')
  const title = document.createElement('h1')
  title.id = 'web3os-splash-title'
  title.innerHTML = options.title || 'web3os'
  title.style.color = options.titleColor || 'white'
  title.style.margin = 0
  title.style.fontSize = options.titleFontSize || 'clamp(0.5rem, 6rem, 7rem)'
  title.style.fontVariant = 'small-caps'
  title.style.textShadow = '4px 4px 4px #888'
  if (!options.disableAnimation) title.classList.add('animate__animated', 'animate__zoomIn')
  const subtitle = document.createElement('h2')
  subtitle.id = 'web3os-splash-subtitle'
  subtitle.innerHTML = options.subtitle || t('kernel:bootIntroSubtitle', 'Made with <span class="heart">♥</span> by Jay Mathis')
  subtitle.style.margin = 0
  subtitle.style.color = options.subtitleColor || '#ccc'
  subtitle.style.fontStyle = options.subtitleFontStyle || 'italic'
  if (subtitle.querySelector('span.heart')) {
    subtitle.querySelector('span.heart').style.color = 'red'
    subtitle.querySelector('span.heart').style.fontSize = '1.5em'
  }
  if (!options.disableAnimation) subtitle.classList.add('animate__animated', 'animate__zoomInDown') && subtitle.style.setProperty('--animate-delay', '0.5s')
  const background = document.createElement('div')
  background.id = 'web3os-splash-background'
  background.style.backgroundColor = '#121212'
  background.style.position = 'absolute'
  background.style.top = 0
  background.style.left = 0
  background.style.width = '100vw'
  background.style.height = '100vh'
  background.style.zIndex = 100001
  const message = document.createElement('h3')
  message.id = 'web3os-splash-message'
  message.style.color = 'silver'
  message.style.fontSize = '2.5rem'
  message.textContent = msg || `💾 ${t('Booting', 'Booting')}... 💾`
  const versionInfo = document.createElement('h4')
  versionInfo.id = 'web3os-splash-version'
  versionInfo.style.color = '#333'
  versionInfo.style.position = 'fixed'
  versionInfo.style.bottom = '0.5rem'
  versionInfo.style.right = '1rem'
  versionInfo.textContent = `v${rootPkgJson.version}`
  const container = document.createElement('div')
  container.id = 'web3os-splash'
  container.style.display = 'flex'
  container.style.position = 'absolute'
  container.style.top = 0
  container.style.left = 0
  container.style.margin = 0
  container.style.flexDirection = 'column'
  container.style.justifyContent = 'center'
  container.style.alignItems = 'center'
  container.style.height = '100vh'
  container.style.width = '100vw'
  container.style.zIndex = 100002
  container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)'
  container.appendChild(title)
  container.appendChild(subtitle)
  container.appendChild(icon)
  container.appendChild(message)
  container.appendChild(versionInfo)
  document.body.appendChild(background)
  document.body.appendChild(container)
  // TODO: Make flexible
  if (!options.disableAnimation) {
    let index = 0
    const icons = ['hourglass_empty', 'hourglass_bottom', 'hourglass_top']
    setTimeout(() => {
      icon.classList.remove('animate__animated', 'animate__zoomIn')
      icon.classList.add('rotating')
    }, 1000)
    setInterval(() => {
      icon.innerText = icons[index]
      index++
      if (!icons[index]) index = 0
    }, 500)
  }
  return () => {
    background.classList.add('animate__animated', 'animate__fadeOut', 'animate__fast')
    container.classList.add('animate__animated', 'animate__fadeOut', 'animate__fast')
    background.addEventListener('animationend', background.remove)
    container.addEventListener('animationend', container.remove)
  }
}
/**
 * Boot the kernel
 * 
 * This kicks off the process of initializing the filesystem, modules, and other components
 * @async
 */
export async function boot () {
  i18n
    .use(i18nextBrowserLanguageDetector)
    .init({
      fallbackLng: 'en-US',
      debug: process.env.I18N_DEBUG === 'true',
      ns: ['common', 'kernel', 'app'],
      defaultNS: 'common',
      resources: locales
    })
  topbar.show()
  const bootArgs = new URLSearchParams(globalThis.location.search)
  globalThis.addEventListener('beforeunload', async () => {
    await showSplash(`${t('Rebooting')}...`, { icon: 'autorenew', disableAnimation: true, disableVideoBackground: true })
    document.querySelector('#web3os-splash-icon').classList.add('rotating')
  })
  // const keyboardElement = document.createElement('div')
  // keyboardElement.classList.add('simple-keyboard')
  // // keyboardElement.style.display = 'none'
  // keyboardElement.style.position = 'absolute'
  // keyboardElement.style.top = '0'
  // document.body.appendChild(keyboardElement)
  // keyboard = new Keyboard({
  //   onChange: input => events.dispatch('MobileKeyboardChange', input),
  //   onKeyPress: button => events.dispatch('MobileKeyboardKeyPress', button)
  // })
  if (!bootArgs.has('nobootsplash')) {
    events.dispatch('ShowSplash')
    const closeSplash = await showSplash()
    setTimeout(closeSplash, 1500) // Prevent splash flash. The splash is pretty and needs to be seen and validated.
    document.querySelector('#web3os-terminal').style.display = 'block'
    setTimeout(globalThis.Terminal?.fit, 50)
    globalThis.Terminal?.focus()
  } else {
    document.querySelector('#web3os-terminal').style.display = 'block'
    setTimeout(globalThis.Terminal?.fit, 50)
    globalThis.Terminal?.focus()
  }
  setInterval(() => globalThis.Terminal?.fit(), 200)
  const isSmall = window.innerWidth <= 445
  figlet.parseFont(figletFontName, figletFont)
  figlet.text('web3os', { font: figletFontName }, async (err, logoFiglet) => {
    if (err) log(err)
    if (logoFiglet && globalThis.innerWidth >= 768) log(`\n${colors.green.bold(logoFiglet)}`)
    else log(`\n${colors.green.bold(`${isSmall ? '' : '\t\t'}🐉  web3os 🐉`)}`)
    console.log(`%cweb3os %c${rootPkgJson.version}`, `
      font-family: "Lucida Console", Monaco, monospace;
      font-size: 25px;
      letter-spacing: 2px;
      word-spacing: 2px;
      color: #028550;
      font-weight: 700;
      font-style: normal;
      font-variant: normal;
      text-transform: none;`, null)
    console.log('%chttps://github.com/web3os-org/kernel', 'font-size:14px;')
    console.debug({ Kernel, Terminal, System })
    for (const event of KernelEvents) {
      events.on(event, payload => {
        let data
        switch (event) {
          case 'ModuleLoaded':
            data = payload.detail.modInfo.name
            break
          default:
            data = payload
        }
        eventsProcessed++
        console.debug('Kernel Event:', { event, data })
      })
    }
    if (!bootArgs.has('nobootintro')) await printBootIntro()
    await loadLocalStorage()
    events.dispatch('MemoryLoaded', memory)
    await setupFilesystem()
    events.dispatch('FilesystemLoaded')
    await registerKernelBins()
    events.dispatch('KernelBinsLoaded')
    await registerBuiltinModules()
    events.dispatch('BuiltinModulesLoaded')
    // Load builtin kernel FS modules into the kernel
    for await (const [name, mod] of Object.entries(await fsModules({ BrowserFS, fs, execute, modules, t, utils }))) {
      loadModule(mod, { name: `@web3os-fs/${name}` })
    }
    events.dispatch('FilesystemModulesLoaded')
    await loadPackages()
    events.dispatch('PackagesLoaded')
    // Copy namespaced core modules onto root object
    const web3osCoreNamespaces = ['@web3os-core', '@web3os-fs']
    for (const mod of Object.values(modules)) {
      const [namespace, name] = mod.name.split('/')
      if (web3osCoreNamespaces.includes(namespace)) modules[name] = mod
    }
    // Check for notification permission and request if necessary
    if (Notification?.permission === 'default') Notification.requestPermission()
    if (Notification?.permission === 'denied') log(colors.warning(t('Notification permission denied')))
    localStorage.setItem('web3os_first_boot_complete', 'true')
    events.dispatch('AutostartStart')
    await autostart()
    events.dispatch('AutostartEnd')
    if (modules.confetti) await execute('confetti --startVelocity 90 --particleCount 150')
    topbar.hide()
    const heartbeat = setInterval(() => navigator.vibrate([200, 50, 200]), 1000)
    setTimeout(() => clearInterval(heartbeat), 5000)
    
    // Expose this globally in case it needs to be cleared externally by an app
    globalThis.web3osBlinkyTitleInterval = setInterval(() => {
      document.title = document.title.includes('_') ? 'web3os# ' : 'web3os# _'
    }, 600)
    events.dispatch('BootComplete')
    console.timeEnd('web3os:boot')
    console.debug('Navigation Performance:', globalThis.performance?.getEntriesByType('navigation')?.[0]?.duration)
    if (location.hostname !== 'localhost') analyticsEvent({ event: 'boot-complete' })
  })
}
/**
 * Wait for the specified number of milliseconds
 * @async
 * @param {number} ms - The number of milliseconds to wait
 * @return {Module}
 */
export async function wait (ms) {
  return new Promise(resolve => setTimeout(resolve, ms))
}
// Setup screensaver interval
let idleTimer
const resetIdleTime = () => {
  clearTimeout(idleTimer)
  if (!memory) return
  const timeout = get('config', 'screensaver-timeout') || Config.screensaverTimeout
  if (!modules?.screensaver || timeout <= 0) return
  const saver = modules.screensaver.getSaver()
  const startTime = modules.screensaver.getStartTime()
  
  // Prevent screensaver from immediately exiting to overcome
  // late enter-key event when entering command at terminal
  if (Date.now() - startTime > 500) saver?.exit?.()
  idleTimer = setTimeout(async () => {
    modules.screensaver.run(globalThis.Terminal, get('config', 'screensaver') || 'matrix')
  }, timeout)
}
// Activity listeners to reset idle time
globalThis.addEventListener('mousemove', resetIdleTime)
globalThis.addEventListener('keydown', resetIdleTime)
globalThis.addEventListener('keyup', resetIdleTime)
globalThis.addEventListener('keypress', resetIdleTime)
globalThis.addEventListener('pointerdown', resetIdleTime)
// Setup protocol handler
if (navigator.registerProtocolHandler) navigator.registerProtocolHandler('web+threeos', '?destination=%s')
// Handle PWA installability
globalThis.addEventListener('beforeinstallprompt', e => {
  const installer = {
    name: '@web3os-core/install',
    description: t('kernel:bins.descriptions.install', 'Install web3os as a PWA'),
    run: async () => {
      const result = await e.prompt()
      Terminal.log(result)
      analyticsEvent({ event: 'pwa-install', details: result })
    }
  }
  modules[installer.name] = installer
  modules.install = installer
})
// Register service worker
if ('serviceWorker' in navigator && location.hostname !== 'localhost') {
  globalThis.addEventListener('load', () => {
    navigator.serviceWorker.register('/service-worker.js')
  })
}
JAVASCRIPT
Copied!