@owdproject/core 3.1.4-beta.0 → 3.1.4

package/module.ts

@@ -35,7 +35,7 @@ export default defineNuxtModule({
       ).default
 
     } catch (e) {
-      console.error('/desktop/owd.config.ts not found or invalid')
+      console.error('/desktop/owd.config.ts not found or invalid', e)
       return
     }
 
@@ -50,9 +50,17 @@ export default defineNuxtModule({
       ...clientConfig
     }
 
-    // set core version to runtime config
+    // init desktop runtime config and define core version
 
-    _nuxt.options.runtimeConfig.public.coreVersion = pkg.version
+    _nuxt.options.runtimeConfig.public.desktop = {
+      coreVersion: pkg.version
+    }
+
+    // assign open web desktop config to runtime config
+    _nuxt.options.runtimeConfig.public.desktop = deepMerge(
+      _nuxt.options.runtimeConfig.public.desktop,
+      clientConfig
+    )
 
     {
       // install open web desktop theme
@@ -77,13 +85,13 @@ export default defineNuxtModule({
         }
       }
 
-      // assign open web desktop config to runtime config
-      _nuxt.options.runtimeConfig.public.desktop = deepMerge(
-        _nuxt.options.runtimeConfig.public.desktop,
-        clientConfig
-      )
     }
 
+    // assign runtimeConfig desktop prop to appConfig
+    // to make it overwritable by components later
+    // via useDesktopManager
+    _nuxt.options.appConfig.desktop = _nuxt.options.runtimeConfig.public.desktop
+
     {
       // install primevue
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owdproject/core",
-  "version": "3.1.4-beta.0",
+  "version": "3.1.4",
   "keywords": [
     "web",
     "desktop",
@@ -48,6 +48,6 @@
     "sass": "^1.89.2",
     "shellwords": "^1.0.1",
     "vue-resizable": "^2.1.7",
-    "yargs-parser": "^22.0.0"
+    "getopts": "^2.3.0"
   }
 }

package/runtime/components/Core/Application/CoreApplicationRender.vue

@@ -10,7 +10,7 @@ const applicationManager = useApplicationManager()
 
 <template>
   <CoreApplicationWindowsRender
-    v-for="app of applicationManager.appsRunning"
+    v-for="app of applicationManager.appsRunning.value"
     :key="app.id"
     :workspace-filter="workspaceFilter"
     :windows="app.windowsOpened"

package/runtime/components/Core/Desktop/CoreDesktop.vue

@@ -1,10 +1,10 @@
 <script setup lang="ts">
-import { onMounted, onUnmounted } from 'vue'
-import { useRuntimeConfig } from 'nuxt/app'
+import { onBeforeMount, onMounted, onUnmounted } from 'vue'
+import { useAppConfig, useRuntimeConfig } from 'nuxt/app'
 import { computed, toRaw } from '@vue/reactivity'
 import { useDesktopManager } from '../../../composables/useDesktopManager'
-import { useApplicationManager } from '../../../composables/useApplicationManager'
 import { useDesktopStore } from '../../../stores/storeDesktop'
+import { useDesktopDefaultAppsStore } from '../../../stores/storeDesktopDefaultApps'
 import { useDesktopWorkspaceStore } from '../../../stores/storeDesktopWorkspace'
 
 const props = withDefaults(
@@ -25,9 +25,11 @@ const props = withDefaults(
 )
 
 // todo move to owd initialization
+// perhaps in a plugin
 
+const appConfig = useAppConfig()
 const desktopManager = useDesktopManager()
-const applicationManager = useApplicationManager()
+const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
 const runtimeConfig = useRuntimeConfig()
 
 // create firsts workspaces if not available
@@ -42,8 +44,6 @@ if (desktopStore.$persistedState) {
   desktopWorkspaceStore.setupWorkspaces()
 }
 
-desktopManager.setConfig(runtimeConfig.public.desktop)
-
 // override desktop configurations
 desktopManager.setConfig({
   windows: toRaw(props.windows),
@@ -65,10 +65,14 @@ function handleDesktopResize() {
 const classes = computed(() => {
   const list = ['owd-desktop']
 
-  list.push(`owd-desktop--${desktopManager.config.name}`)
+  list.push(`owd-desktop--${appConfig.desktop.name}`)
 
   return list
 })
+
+onBeforeMount(() => {
+  desktopDefaultAppsStore.loadDefaultAppsFromConfig(runtimeConfig)
+})
 </script>
 
 <template>

package/runtime/components/Core/Window/CoreWindow.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { ref, provide } from 'vue'
 import { computed } from '@vue/reactivity'
+import { useAppConfig } from 'nuxt/app'
 import { useDesktopManager } from '@owdproject/core/runtime/composables/useDesktopManager'
 import { handleWindowControllerProps } from '@owdproject/core/runtime/utils/utilWindow'
 
@@ -27,6 +28,7 @@ const emit = defineEmits([
   'toggle-maximize',
 ])
 
+const appConfig = useAppConfig()
 const desktopManager = useDesktopManager() // used in <style v-bind>
 const windowController: IWindowController = handleWindowControllerProps(
   props.window,
@@ -151,7 +153,7 @@ const classes = computed(() => {
 
 <style scoped lang="scss">
 .owd-window {
-  position: v-bind('desktopManager.config.windows.position');
+  position: v-bind('appConfig.desktop.windows.position');
 
   &--dragging,
   &--resizing {

package/runtime/composables/useApplicationEntries.ts

@@ -21,7 +21,7 @@ export function useApplicationEntries() {
     visibility: Visibility = 'primary',
   ): Ref<ApplicationEntryWithInherited[]> {
     return computed(() => {
-      const currentEntries = [...applicationManager.appsEntries]
+      const currentEntries = [...applicationManager.appsEntries.value]
 
       // filtering
       const filtered =

package/runtime/composables/useApplicationManager.ts

@@ -1,7 +1,280 @@
-import { ApplicationManager } from '../core/managers/ApplicationManager'
+import { reactive, markRaw, computed } from 'vue'
+import { ApplicationController } from '../core/controllers/ApplicationController'
+import { normalizeApplicationConfig } from '../utils/utilApp'
+import { debugLog } from '../utils/utilDebug'
+import * as shellwords from 'shellwords'
+import getopts from "getopts"
 
-const applicationManager = new ApplicationManager()
+const apps = reactive(new Map<string, IApplicationController>())
 
-export function useApplicationManager(): IApplicationManager {
-  return applicationManager
+/**
+ * Application Manager Composable (Singleton)
+ */
+export function useApplicationManager() {
+  /**
+   * Define new application
+   *
+   * @param id
+   * @param config
+   */
+  async function defineApp(id: string, config: ApplicationConfig) {
+    if (isAppDefined(id)) {
+      debugLog(`App "${id}" is already defined`)
+      return getAppById(id)!
+    }
+
+    const normalizedConfig = normalizeApplicationConfig(config)
+    const applicationConfig = markRaw(normalizedConfig)
+
+    const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
+    await applicationController.initApplication()
+
+    apps.set(id, applicationController)
+
+    return applicationController
+  }
+
+  /**
+   * Check if app has been defined
+   *
+   * @param {string} id
+   */
+  function isAppDefined(id: string) {
+    return getAppById(id)
+  }
+
+  /**
+   * Retrieves an app instance by its unique identifier
+   *
+   * @param {string} id
+   */
+  function getAppById(id: string) {
+    return apps.get(id)
+  }
+
+  /**
+   * Check if app is running
+   *
+   * @param {string} id
+   */
+  function isAppRunning(id: string) {
+    if (!isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
+
+    const applicationController = getAppById(id)!
+    return applicationController.isRunning
+  }
+
+  /**
+   * Launch app entry
+   *
+   * @param id
+   * @param entryKey
+   * @param argument
+   */
+  async function launchAppEntry(
+    id: string,
+    entryKey: string,
+    argument: string = ''
+  ): Promise<IApplicationController | undefined | void> {
+    if (!isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
+
+    const applicationController = getAppById(id)!
+
+    if (
+      applicationController.config.entries &&
+      !applicationController.config.entries.hasOwnProperty(entryKey)
+    ) {
+      throw Error(`App entry "${entryKey}" is not defined in ${id} application`)
+    }
+
+    const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
+
+    if (argument) argument = ` ${argument}`
+
+    await execAppCommand(applicationController.id, entry.command + argument)
+  }
+
+  /**
+   * Run app command
+   *
+   * @param id
+   * @param rawCommand
+   */
+  async function execAppCommand(
+    id: string,
+    rawCommand: string,
+  ): Promise<CommandOutput> {
+    if (!isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
+
+    const applicationController = getAppById(id)!
+
+    const args = shellwords.split(rawCommand)
+    const parsed = getopts(args)
+    const command: string = parsed._[0]
+
+    if (
+      applicationController.config.commands &&
+      !applicationController.config.commands.hasOwnProperty(command)
+    ) {
+      throw Error(
+        `App command "${command}" is not defined in ${id} application`,
+      )
+    }
+
+    const commandFn: any = applicationController.config.commands![command]
+
+    const commandOutput = await commandFn(applicationController, parsed)
+
+    applicationController.setRunning(true)
+
+    return commandOutput
+  }
+
+  /**
+   * Close application
+   *
+   * @param id
+   */
+  function closeApp(id: string) {
+    if (!isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
+
+    const applicationController = getAppById(id)!
+
+    applicationController.closeAllWindows()
+    applicationController.setRunning(false)
+  }
+
+  /**
+   * Array of available menu entries for system bars, docks
+   */
+  const appsEntries = computed(() => {
+    const entries: ApplicationEntryWithInherited[] = []
+
+    for (const applicationController of apps.values()) {
+      if (!applicationController.config.entries) {
+        continue
+      }
+
+      for (const entryKey of Object.keys(applicationController.config.entries)) {
+        const entry = applicationController.config.entries[entryKey]!
+
+        entries.push({
+          application: applicationController,
+          title: entry.title ?? applicationController.config.title,
+          icon: entry.icon ?? applicationController.config.icon,
+          category: entry.category ?? applicationController.config.category,
+          visibility: entry.visibility ?? 'primary',
+          command: entry.command,
+        })
+      }
+    }
+
+    return entries
+  })
+
+  /**
+   * Array of opened windows for system bars, docks
+   */
+  const windowsOpened = computed(() => {
+    const windows: Map<string, IWindowController>[] = []
+
+    for (const applicationController of apps.values()) {
+      if (applicationController.isRunning) {
+        windows.push(...applicationController.windows)
+      }
+    }
+
+    return windows
+  })
+
+  /**
+   * Array of running applications
+   */
+  const appsRunning = computed(() => {
+    const runningApps: IApplicationController[] = []
+
+    for (const applicationController of apps.values()) {
+      if (applicationController.isRunning) {
+        runningApps.push(applicationController)
+      }
+    }
+
+    return runningApps
+  })
+
+  function getWindowOpenedId(windowId: string) {
+    const mapWindowFound = windowsOpened.value.find((window: any) => {
+      return window[1].state.id === windowId
+    })
+
+    if (mapWindowFound) {
+      // @ts-ignore
+      return mapWindowFound[1] as IWindowController
+    }
+  }
+
+  /**
+   * Gets all unique categories from the installed apps
+   */
+  const appCategories = computed(() => {
+    const categories = new Set<string>()
+
+    for (const applicationController of apps.values()) {
+      if (applicationController.config.category) {
+        categories.add(applicationController.config.category)
+      }
+    }
+
+    return Array.from(categories).sort()
+  })
+
+  /**
+   * Gets the apps ordered by category
+   */
+  const appsByCategory = computed(() => {
+    const categorizedApps: {
+      [category: string]: IApplicationController[]
+    } = {}
+
+    for (const applicationController of apps.values()) {
+      const category = applicationController.config.category || 'other'
+      if (!categorizedApps[category]) {
+        categorizedApps[category] = []
+      }
+      categorizedApps[category].push(applicationController)
+    }
+
+    for (const category in categorizedApps) {
+      categorizedApps[category].sort((a, b) =>
+        a.config.title.localeCompare(b.config.title),
+      )
+    }
+
+    return categorizedApps
+  })
+
+  return {
+    apps,
+    defineApp,
+    isAppDefined,
+    getAppById,
+    isAppRunning,
+    launchAppEntry,
+    execAppCommand,
+    closeApp,
+    getWindowOpenedId,
+    appsEntries,
+    appsRunning,
+    windowsOpened,
+    appCategories,
+    appsByCategory,
+  }
 }

package/runtime/composables/useDesktopManager.ts

@@ -1,7 +1,25 @@
-import { DesktopManager } from '../core/managers/DesktopManager'
-
-const desktopManager = new DesktopManager()
+import { deepMerge } from '../utils/utilCommon'
+import { useAppConfig } from 'nuxt/app'
 
+/**
+ * Desktop Manager Composable (Singleton)
+ */
 export function useDesktopManager() {
-  return desktopManager
+  /**
+   * Merges and sets the desktop config at runtime
+   *
+   * @param newConfig
+   */
+  function setConfig(newConfig: DesktopConfig) {
+    const appConfig = useAppConfig()
+
+    appConfig.desktop = deepMerge(
+      appConfig.desktop,
+      newConfig,
+    ) as DesktopConfig
+  }
+
+  return {
+    setConfig,
+  }
 }

package/runtime/composables/useTerminalManager.ts

@@ -1,7 +1,66 @@
-import { TerminalManager } from '../core/managers/TerminalManager'
+import { useApplicationManager } from './useApplicationManager'
+import { debugLog } from '../utils/utilDebug'
 
-const terminalManager = new TerminalManager()
+const commands = new Map<string, TerminalCommand>()
 
+/**
+ * Terminal Manager Composable (Singleton)
+ */
 export function useTerminalManager() {
-  return terminalManager
+  /**
+   * Add a new terminal command
+   *
+   * @param command
+   */
+  const addCommand = (command: TerminalCommand) => {
+    for (const existingCommand of commands.keys()) {
+      if (
+        existingCommand.startsWith(command.name) ||
+        command.name.startsWith(existingCommand)
+      ) {
+        throw new Error(`Command prefix conflict with "${existingCommand}"`)
+      }
+    }
+
+    commands.set(command.name, command)
+    debugLog(`Registered terminal command: ${command.name} → ${command.applicationId}`)
+  }
+
+  /**
+   * List all registered command names
+   */
+  const listCommands = (): string[] => {
+    return Array.from(commands.keys())
+  }
+
+  /**
+   * Execute a terminal command
+   *
+   * @param input
+   */
+  const execCommand = async (input: string): Promise<CommandOutput | void> => {
+    const applicationManager = useApplicationManager()
+
+    const [name, ...args] = input.trim().split(/\s+/)
+
+    if (!name) {
+      return
+    }
+
+    if (!commands.has(name)) {
+      return {
+        message: `Command "${name}" not found`,
+      }
+    }
+
+    const application = commands.get(name)!
+
+    return applicationManager.execAppCommand(application.applicationId, input)
+  }
+
+  return {
+    addCommand,
+    listCommands,
+    execCommand,
+  }
 }

package/runtime/core/controllers/ApplicationController.ts

@@ -4,14 +4,13 @@ import { useApplicationManager } from '../../composables/useApplicationManager'
 import { useApplicationWindowsStore } from '../../stores/storeApplicationWindows'
 import { useApplicationMetaStore } from '../../stores/storeApplicationMeta'
 import { useTerminalManager } from '../../composables/useTerminalManager'
-import { useDesktopManager } from '../../composables/useDesktopManager'
 import { debugLog, debugError } from '../../utils/utilDebug'
+import { useDesktopDefaultAppsStore } from '../../stores/storeDesktopDefaultApps'
 import { useDesktopWorkspaceStore } from '../../stores/storeDesktopWorkspace'
 import { reactive } from '@vue/reactivity'
 
 export class ApplicationController implements IApplicationController {
   private readonly applicationManager: IApplicationManager
-  private readonly desktopManager: IDesktopManager
   private readonly terminalManager: ITerminalManager
 
   public readonly id
@@ -26,7 +25,6 @@ export class ApplicationController implements IApplicationController {
   constructor(id: string, config: ApplicationConfig) {
     this.applicationManager = useApplicationManager()
     this.terminalManager = useTerminalManager()
-    this.desktopManager = useDesktopManager()
 
     this.id = id
     this.config = config
@@ -35,20 +33,22 @@ export class ApplicationController implements IApplicationController {
   }
 
   public async initApplication(): Promise<void> {
+    const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
+
     // provides
 
     // set as default app for specific purposes
     // todo improve this and move it in a store
     if (this.config.provides) {
-      const existingDefault = this.desktopManager.getDefaultApp(
+      const existingDefault = desktopDefaultAppsStore.getDefaultApp(
         this.config.provides.name,
       )
 
       if (!existingDefault) {
-        this.desktopManager.setDefaultApp(
+        desktopDefaultAppsStore.setDefaultApp(
           this.config.provides.name,
           this,
-          this.config.provides.command,
+          this.config.provides.entry,
         )
 
         debugLog(

package/runtime/core/controllers/WindowController.ts

@@ -208,7 +208,7 @@ export class WindowController implements IWindowController {
     }
 
     // set focus false on all other windows
-    for (const [windowId, window] of applicationManager.windowsOpened) {
+    for (const [windowId, window] of applicationManager.windowsOpened.value) {
       window.actions.setFocus(false)
     }
 
@@ -283,7 +283,7 @@ export class WindowController implements IWindowController {
       maxHeight:
         typeof stateSize.maxHeight !== 'undefined'
           ? stateSize.maxHeight
-          : (configSize.maxHeight ?? 600),
+          : configSize.maxHeight,
     }
   }
 

package/runtime/stores/storeApplication.ts

@@ -1,3 +1,5 @@
+// actually unused
+
 import { defineStore } from 'pinia'
 import { reactive, ref, computed } from 'vue'
 import { nanoid } from 'nanoid'
@@ -6,7 +8,7 @@ import { useApplicationManager } from '../composables/useApplicationManager'
 import { useApplicationWindowsStore } from './storeApplicationWindows'
 import { useApplicationMetaStore } from './storeApplicationMeta'
 import { useTerminalManager } from '../composables/useTerminalManager'
-import { useDesktopManager } from '../composables/useDesktopManager'
+import { useDesktopDefaultAppsStore } from './storeDesktopDefaultApps'
 import { useDesktopWorkspaceStore } from './storeDesktopWorkspace'
 import { debugLog, debugError } from '../utils/utilDebug'
 
@@ -22,13 +24,12 @@ export const useApplicationStore = function(applicationId: string, applicationCo
     const windows = reactive(new Map<string, WindowController>())
     const isRunning = ref<boolean>(false)
 
-    // composables e stores esterni
+    // composables and external stores
     const applicationManager = useApplicationManager()
     const terminalManager = useTerminalManager()
-    const desktopManager = useDesktopManager()
+    const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
     const desktopWorkspaceStore = useDesktopWorkspaceStore()
 
-    // stores figli
     let storeWindows: ReturnType<typeof useApplicationWindowsStore>
     let storeMeta: ReturnType<typeof useApplicationMetaStore>
 
@@ -37,13 +38,13 @@ export const useApplicationStore = function(applicationId: string, applicationCo
       storeWindows = useApplicationWindowsStore(applicationId)
       storeMeta = useApplicationMetaStore(applicationId)
 
-      // Fornisci applicazione di default se presente
+      // set default app
       if (applicationConfig.provides) {
-        const existingDefault = desktopManager.getDefaultApp(
+        const existingDefault = desktopDefaultAppsStore.getDefaultApp(
           applicationConfig.provides.name,
         )
         if (!existingDefault) {
-          desktopManager.setDefaultApp(
+          desktopDefaultAppsStore.setDefaultApp(
             applicationConfig.provides.name,
             store, // store o qualcosa che rappresenta questa app?
             applicationConfig.entries![applicationConfig.provides.entry]!,
@@ -54,7 +55,7 @@ export const useApplicationStore = function(applicationId: string, applicationCo
         }
       }
 
-      // registra comandi terminale
+      // register terminal commands
       if (applicationConfig.commands) {
         for (const commandKey of Object.keys(applicationConfig.commands)) {
           terminalManager.addCommand({

package/runtime/stores/storeDesktop.ts

@@ -16,6 +16,7 @@ export const useDesktopStore = defineStore(
       window: {
         positionZ: number
       }
+      defaultApps: {[key: string]: string}
     }>({
       workspace: {
         overview: false,
@@ -28,6 +29,7 @@ export const useDesktopStore = defineStore(
       window: {
         positionZ: 0,
       },
+      defaultApps: {}
     })
 
     return {

package/runtime/stores/storeDesktopDefaultApps.ts

@@ -0,0 +1,53 @@
+import { defineStore } from 'pinia'
+import { useDesktopStore } from './storeDesktop'
+
+export const useDesktopDefaultAppsStore = defineStore(
+  'owd/desktop/defaultApps',
+  () => {
+    const desktopStore = useDesktopStore()
+
+    /**
+     * Sets a default app for a given feature
+     */
+    function setDefaultApp(
+      feature: string,
+      application: IApplicationController,
+      entry: string,
+    ) {
+      if (!desktopStore.state.hasOwnProperty('defaultApps')) {
+        desktopStore.state.defaultApps = {}
+      }
+
+      desktopStore.state.defaultApps[feature] = {
+        applicationId: application.id,
+        entry,
+      }
+    }
+
+    /**
+     * Gets the default app config for a given feature
+     */
+    function getDefaultApp(feature: string): DefaultAppConfig {
+      if (!desktopStore.state.hasOwnProperty('defaultApps')) {
+        desktopStore.state.defaultApps = {}
+      }
+
+      return desktopStore.state.defaultApps[feature] as DefaultAppConfig
+    }
+
+    /**
+     * Loads default apps from current config
+     */
+    function loadDefaultAppsFromConfig(runtimeConfig) {
+      if (runtimeConfig.public.desktop.defaultApps) {
+        desktopStore.state.defaultApps = runtimeConfig.public.desktop.defaultApps
+      }
+    }
+
+    return {
+      setDefaultApp,
+      getDefaultApp,
+      loadDefaultAppsFromConfig,
+    }
+  },
+)

package/runtime/composables/useClipboardFs.ts

@@ -1,25 +0,0 @@
-import { ref } from 'vue'
-
-type ClipboardOperation = 'copy' | 'cut'
-
-const clipboardFiles = ref<string[]>([])
-const clipboardType = ref<ClipboardOperation | null>(null)
-
-export function useClipboardFs() {
-  function setClipboard(paths: string[], type: ClipboardOperation) {
-    clipboardFiles.value = paths
-    clipboardType.value = type
-  }
-
-  function clearClipboard() {
-    clipboardFiles.value = []
-    clipboardType.value = null
-  }
-
-  return {
-    clipboardFiles,
-    clipboardType,
-    setClipboard,
-    clearClipboard,
-  }
-}

package/runtime/core/managers/ApplicationManager.ts

@@ -1,281 +0,0 @@
-import type { Reactive } from '@vue/reactivity'
-import { reactive, markRaw } from '@vue/reactivity'
-import { ApplicationController } from '../controllers/ApplicationController'
-import { normalizeApplicationConfig } from '../../utils/utilApp'
-import { debugLog } from '../../utils/utilDebug'
-import * as shellwords from 'shellwords'
-import yargsParser from 'yargs-parser'
-
-export class ApplicationManager implements IApplicationManager {
-  public apps = reactive(new Map<string, IApplicationController>())
-
-  constructor() {}
-
-  /**
-   * Define new application
-   *
-   * @param id
-   * @param config
-   */
-  public async defineApp(id: string, config: ApplicationConfig) {
-    if (this.isAppDefined(id)) {
-      debugLog(`App "${id}" is already defined`)
-      return this.getAppById(id)!
-    }
-
-    const normalizedConfig = normalizeApplicationConfig(config)
-    const applicationConfig = markRaw(normalizedConfig)
-
-    const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
-    await applicationController.initApplication()
-
-    this.apps.set(id, applicationController)
-
-    return applicationController
-  }
-
-  /**
-   * Check if app has been defned
-   *
-   * @param {string} id
-   */
-  public isAppDefined(id: string) {
-    return this.getAppById(id)
-  }
-
-  /**
-   * Retrieves an app instance by its unique identifier
-   *
-   * @param {string} id
-   */
-  public getAppById(id: string) {
-    return this.apps.get(id)
-  }
-
-  /**
-   * Check if app is running
-   *
-   * @param {string} id
-   */
-  public isAppRunning(id: string) {
-    if (!this.isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController: IApplicationController = this.getAppById(id)!
-
-    if (!applicationController.isRunning) {
-      return false
-    }
-
-    return true
-  }
-
-  /**
-   * Launch app entry
-   *
-   * @param id
-   * @param entryKey
-   */
-  public async launchAppEntry(
-    id: string,
-    entryKey: string,
-  ): Promise<IApplicationController | undefined | void> {
-    if (!this.isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController: IApplicationController = this.getAppById(id)!
-
-    if (
-      applicationController.config.entries &&
-      !applicationController.config.entries.hasOwnProperty(entryKey)
-    ) {
-      throw Error(`App entry "${entryKey}" is not defined in ${id} application`)
-    }
-
-    const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
-
-    await this.execAppCommand(applicationController.id, entry.command)
-  }
-
-  /**
-   * Run app command
-   *
-   * @param id
-   * @param rawCommand
-   */
-  public async execAppCommand(
-    id: string,
-    rawCommand: string,
-  ): Promise<CommandOutput> {
-    if (!this.isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController: IApplicationController = this.getAppById(id)!
-
-    const args = shellwords.split(rawCommand)
-    const parsed = yargsParser(args)
-    const command: string = parsed._[0]
-
-    if (
-      applicationController.config.commands &&
-      !applicationController.config.commands.hasOwnProperty(command)
-    ) {
-      throw Error(
-        `App command "${command}" is not defined in ${id} application`,
-      )
-    }
-
-    const commandFn: any = applicationController.config.commands![command]
-
-    const commandOutput = await commandFn(
-      applicationController,
-      parsed,
-    )
-
-    applicationController.setRunning(true)
-
-    return commandOutput
-  }
-
-  /**
-   * Close application
-   *
-   * @param id
-   */
-  public closeApp(id: string) {
-    if (!this.isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController: IApplicationController = this.getAppById(id)!
-
-    applicationController.closeAllWindows()
-    applicationController.setRunning(false)
-  }
-
-  /**
-   * Array of available menu entries for system bars, docks
-   */
-  public get appsEntries() {
-    const entries: Reactive<ApplicationEntryWithInherited[]> = reactive([])
-
-    for (const applicationController of this.apps.values()) {
-      if (!applicationController.config.entries) {
-        continue
-      }
-
-      for (const entryKey of Object.keys(
-        applicationController.config.entries,
-      )) {
-        const entry: ApplicationEntry =
-          applicationController.config.entries[entryKey]!
-
-        entries.push({
-          application: applicationController,
-          title:
-            entry.title !== undefined
-              ? entry.title
-              : applicationController.config.title,
-          icon:
-            entry.icon !== undefined
-              ? entry.icon
-              : applicationController.config.icon,
-          category:
-            entry.category !== undefined
-              ? entry.category
-              : applicationController.config.category,
-          visibility: entry.visibility ?? 'primary',
-          command: entry.command,
-        })
-      }
-    }
-
-    return entries
-  }
-
-  /**
-   * Array of opened windows for system bars, docks
-   */
-  public get windowsOpened() {
-    const windows: Reactive<Map<string, IWindowController>[]> = reactive([])
-
-    for (const applicationController of this.apps.values()) {
-      if (applicationController.isRunning) {
-        windows.push(...applicationController.windows)
-      }
-    }
-
-    return windows
-  }
-
-  /**
-   * Array of opened windows for system bars, docks
-   */
-  public get appsRunning() {
-    const applications: Reactive<IApplicationController[]> = reactive([])
-
-    for (const applicationController of this.apps.values()) {
-      if (applicationController.isRunning) {
-        applications.push(applicationController)
-      }
-    }
-
-    return applications
-  }
-
-  public getWindowOpenedId(windowId: string) {
-    const mapWindowFound: Map<string, IWindowController> | undefined =
-      this.windowsOpened.find((window: any) => {
-        return window[1].state.id === windowId
-      })
-
-    if (mapWindowFound) {
-      // @ts-ignore
-      return mapWindowFound[1] as IWindowController
-    }
-  }
-
-  /**
-   * Gets all unique categories from the installed apps
-   */
-  public get appCategories(): string[] {
-    const categories = new Set<string>()
-
-    for (const applicationController of this.apps.values()) {
-      if (applicationController.config.category) {
-        categories.add(applicationController.config.category)
-      }
-    }
-    return Array.from(categories).sort()
-  }
-
-  /**
-   * Gets the apps ordered by category
-   */
-  public get appsByCategory(): {
-    [category: string]: IApplicationController[]
-  } {
-    const categorizedApps: {
-      [category: string]: IApplicationController[]
-    } = {}
-
-    for (const applicationController of this.apps.values()) {
-      const category = applicationController.config.category || 'other'
-      if (!categorizedApps[category]) {
-        categorizedApps[category] = []
-      }
-      categorizedApps[category].push(applicationController)
-    }
-
-    for (const category in categorizedApps) {
-      categorizedApps[category]!.sort((a, b) =>
-        a.config.title.localeCompare(b.config.title),
-      )
-    }
-
-    return categorizedApps
-  }
-}

package/runtime/core/managers/DesktopManager.ts

@@ -1,47 +0,0 @@
-export class DesktopManager {
-  private defaultApps: DefaultAppsConfig = {}
-
-  constructor() {}
-
-  get config(): DesktopConfig {
-    const runtimeConfig = useRuntimeConfig()
-
-    return runtimeConfig.public.desktop
-  }
-
-  public hasFeature(featureName: string) {
-    return this.config.features?.indexOf(featureName) !== -1
-  }
-
-  public setConfig(config: DesktopConfig) {
-    const runtimeConfig = useRuntimeConfig()
-
-    runtimeConfig.public.desktop = deepMerge(
-      runtimeConfig.public.desktop,
-      config
-    ) as DesktopConfig
-
-    this.loadDefaultAppsFromConfig()
-  }
-
-  public setDefaultApp(
-    feature: string,
-    application: IApplicationController,
-    command: string,
-  ) {
-    this.defaultApps[feature] = {
-      application,
-      command,
-    }
-  }
-
-  public getDefaultApp(feature: string): DefaultAppConfig {
-    return this.defaultApps[feature] as DefaultAppConfig
-  }
-
-  private loadDefaultAppsFromConfig() {
-    if (this.config.defaultApps) {
-      this.defaultApps = { ...this.config.defaultApps }
-    }
-  }
-}

package/runtime/core/managers/TerminalManager.ts

@@ -1,48 +0,0 @@
-import { useApplicationManager } from '../../composables/useApplicationManager'
-import { debugLog } from '../../utils/utilDebug'
-
-export class TerminalManager {
-  private commands: Map<string, TerminalCommand> = new Map()
-
-  constructor() {}
-
-  public addCommand(command: TerminalCommand) {
-    for (const existingCommand of this.commands.keys()) {
-      if (
-        existingCommand.startsWith(command.name) ||
-        command.name.startsWith(existingCommand)
-      ) {
-        throw new Error(`Command prefix conflict with "${existingCommand}"`)
-      }
-    }
-
-    this.commands.set(command.name, command)
-    debugLog(
-      `Registered terminal command: ${command.name} → ${command.applicationId}`,
-    )
-  }
-
-  public listCommands(): string[] {
-    return Array.from(this.commands.keys())
-  }
-
-  public async execCommand(input: string): Promise<CommandOutput | void> {
-    const applicationManager = useApplicationManager()
-
-    const [name, ...args] = input.trim().split(/\s+/)
-
-    if (!name) {
-      return
-    }
-
-    if (!this.commands.has(name)) {
-      return {
-        message: `Command "${name}" not found`,
-      }
-    }
-
-    const application = this.commands.get(name)!
-
-    return applicationManager.execAppCommand(application.applicationId, input)
-  }
-}