@owdproject/core 3.0.0-alpha.6 → 3.0.0-alpha.8

package/README.md

@@ -3,13 +3,13 @@
 </p>
 <h1 align="center">Open Web Desktop</h1>
 <h3 align="center">
-  A framework for building web-based desktop experiences
+  A framework for building web-based desktop experiences.
 </h3>
 
 ## Overview
 Open Web Desktop (OWD) is a framework designed to provide a simple environment for building web-based desktop experiences. It's built with TypeScript on top of the Nuxt.js framework.
 
-[Check out the demo](https://owdproject.github.io/docs) of the `client` base repository, decked with essential modules.
+[Check out the demo](https://owdproject.github.io/docs) of the `client` base repository, decked with a couple of modules.
 
 ## Features
 - Open-source web desktop environment built with Nuxt.js
@@ -26,11 +26,11 @@ Required software:
 - [Node](https://nodejs.org)
 
 When you are ready, bootstrap a new project by running:
-```
+```bash
 npm create owd
 ```
 Once the process is complete, you can start to develop:
-```
+```bash
 # Run the dev server with hot-reload
 npm run dev
 
@@ -46,49 +46,58 @@ You can simply install a new application and define it this way.
 
 ```typescript
 // owd.config.ts
-import AppTodo from 'owd-app-todo/owd.config'
-
-export const owdConfig = {
-    theme: ['github:owdproject/theme-win95', { install: true }],
-
-    // apps to import
+export default defineDesktopConfig({
     apps: [
-       './node_modules/owd-app-todo',
-    ],
-
-    loader: async () => {
-        await defineDesktopApp(AppTodo)
-    }
-}
+        "@owdproject/app-about",
+        "@owdproject/app-todo",
+    ]
+})
 ```
 
 ## Themes
 Themes allow you to customize the look and feel of your Open Web Desktop instance.
+You can explore available themes, ranging from popular OS designs to fully custom creations, at [topics/owd-themes](https://github.com/topics/owd-themes).
 
 ### Install a new theme
-Install a new theme by defining its location in the `theme` property of your configuration file.  
-Themes can be loaded from local paths or directly from GitHub repositories.
+You can install a new theme by defining it in the `owd.config.ts` configuration.  
+Themes can be loaded from a local path or directly from a GitHub repository.
+
+#### Using a local theme
+
+Clone it first in a folder of your project like `./desktop/theme/theme-gnome`.
 
-**1. Using a local theme:**
+```bash
+git clone git@github.com:owdproject/theme-gnome.git ./desktop/theme/theme-gnome
+```
 
-To use a theme from a local folder, specify the path like this:
+Then specify the path theme in `owd.config.ts`:
 
 ```typescript
 // owd.config.ts
-export const owdConfig = {
-    theme: './desktop/themes/owd-theme-win95',
-}
+export default defineDesktopConfig({
+    theme: './dev/themes/theme-gnome', // define here the theme you just cloned
+    apps: [
+    ...
 ```
 
-**2. Using a theme from GitHub:**
+#### Using a theme package
 
-To use a theme directly from a GitHub repository, specify it in this format: `github:<username>/<repository>`:
+Use npm to install the theme package as a dependency of your Open Web Desktop client:
+
+```bash
+npm install @owdproject/theme-gnome
+```
+
+Then specify the path theme in `owd.config.ts`:
 
 ```typescript
 // owd.config.ts
-export const owdConfig = {
-    theme: ['github:owdproject/theme-win95', { install: true }],
-}
+import {defineDesktopConfig} from "@owdproject/core/runtime/utils/utilsDesktop"
+
+export default defineDesktopConfig({
+    theme: '@owdproject/theme-gnome', // define here the theme you just installed
+    apps: [
+        ...
 ```
 
 ## Contributing
@@ -111,10 +120,10 @@ Then, clone your fork using HTTPS or SSH:
 
 ```bash
 # Clone using HTTPS
-git clone https://github.com/<your-username>/owd-client.git
+git clone https://github.com/<your-username>/client.git
 
 # Clone using SSH
-git clone git@github.com:<your-username>/owd-client.git
+git clone git@github.com:<your-username>/client.git
 ```
 
 Once you have cloned the repository, navigate to the project folder.  
@@ -130,10 +139,10 @@ npm run dev
 This will launch Open Web Desktop in development mode, allowing you to test your changes and see them reflected in real-time.
 The dev server will be available at http://localhost:3000.
 
-## Getting Involved
+## Sponsoring
 
 Open Web Desktop is a vast project. The code has been totally rewritten and is now actively being developed, but your support is what makes it all possible. If you're enjoying it and want to see more, consider donating. Your contribution helps keep the project alive and awesome.
 
-### License
+## License
 
 Open Web Desktop is released under the [GNU General Public License v3](LICENSE).

package/index.ts

@@ -1,5 +1,5 @@
 import {defineNuxtModule, createResolver, addComponentsDir, addImportsDir, installModule, addPlugin} from '@nuxt/kit'
-import {useDesktopManager} from './runtime/composables/useDesktopManager'
+import {deepMerge} from '@owdproject/core/runtime/utils/utilsCommon'
 import pkg from './package.json'
 
 export default defineNuxtModule({
@@ -9,24 +9,43 @@ export default defineNuxtModule({
     },
     async setup(options, nuxt) {
         const {resolve} = createResolver(import.meta.url)
-        const desktopManager = useDesktopManager()
 
-        await import(nuxt.options.rootDir + '/owd.config.ts')
+        const desktopConfig = (await import(nuxt.options.rootDir + '/owd.config.ts')).default
 
-        // set core version to runtime variables
+        // set core version to runtime config
 
         nuxt.options.runtimeConfig.public.coreVersion = pkg.version
 
         {
 
+            // install open web desktop theme
+
+            if (desktopConfig.theme) {
+                await installModule(desktopConfig.theme)
+            }
+
+            // install open web desktop modules
+
+            if (desktopConfig.modules) {
+                for (const modulePath of desktopConfig.modules) {
+                    await installModule(modulePath)
+                }
+            }
+
             // install open web desktop apps
 
-            if (desktopManager.config.apps) {
-                for (const appPath of desktopManager.config.apps) {
+            if (desktopConfig.apps) {
+                for (const appPath of desktopConfig.apps) {
                     await installModule(appPath)
                 }
             }
 
+            // assign open web desktop config to runtime config
+            nuxt.options.runtimeConfig.public.desktop = deepMerge(
+                nuxt.options.runtimeConfig.public.desktop,
+                desktopConfig
+            )
+
         }
 
         {
@@ -45,11 +64,12 @@ export default defineNuxtModule({
 
             // install tailwind
 
-            const tailwindPaths = nuxt.options.appConfig?.owd?.tailwindPaths || []
+            const tailwindPaths = nuxt.options.runtimeConfig?.owd?.tailwindPaths || []
             tailwindPaths.push('./runtime/components/**/*.{vue,mjs,ts}')  // Aggiungi sempre questo al core
 
             nuxt.options.tailwindcss = nuxt.options.tailwindcss || {}
             nuxt.options.tailwindcss.config = nuxt.options.tailwindcss.config || {}
+            // @ts-ignore
             nuxt.options.tailwindcss.config.content = tailwindPaths
 
             await installModule('@nuxtjs/tailwindcss', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owdproject/core",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-alpha.8",
   "description": "Open Web Desktop core",
   "keywords": [
     "web",
@@ -43,5 +43,8 @@
     "sanitize.css": "^13.0.0",
     "sass": "^1.86.0",
     "vue-resizable": "^2.1.7"
+  },
+  "resolutions": {
+    "vite": "^6.3.2"
   }
 }

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

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import {onMounted, onUnmounted} from "vue"
+import {useRuntimeConfig} from "nuxt/app"
 import {computed, toRaw} from "@vue/reactivity"
 import {useDesktopManager} from "../../../composables/useDesktopManager"
 import {useApplicationManager} from "../../../composables/useApplicationManager"
@@ -10,16 +11,21 @@ const props = withDefaults(defineProps<{
   windows?: DesktopWindowsConfig
   systemBar?: DesktopSystemBarConfig
   dockBar?: DesktopDockBarConfig
+  workspaces?: DesktopWorkspacesConfig
 }>(), {
   windows: {
     position: 'fixed',
   },
   systemBar: {},
   dockBar: {},
+  workspaces: {},
 })
 
+// todo move to owd initialization
+
 const desktopManager = useDesktopManager()
 const applicationManager = useApplicationManager()
+const runtimeConfig = useRuntimeConfig()
 
 // create firsts workspaces if not available
 const desktopStore = useDesktopStore()
@@ -33,11 +39,14 @@ if (desktopStore.$persistedState) {
   desktopWorkspaceStore.setupWorkspaces()
 }
 
+desktopManager.setConfig(runtimeConfig.public.desktop)
+
 // override desktop configurations
 desktopManager.setConfig({
   windows: toRaw(props.windows),
-  systemBar: toRaw( props.systemBar),
+  systemBar: toRaw(props.systemBar),
   dockBar: toRaw(props.dockBar),
+  workspaces: toRaw(props.workspaces),
 })
 
 // desktop resize

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

@@ -114,13 +114,13 @@ const classes = computed(() => {
   <vue-resizable
       ref="windowResizableController"
       :class="classes"
-      :width="windowController?.state.size?.width"
-      :height="windowController?.state.size?.height"
-      :min-height="windowController?.state.size?.minHeight"
-      :max-width="windowController?.state.size?.maxWidth"
-      :max-height="windowController?.state.size?.maxHeight"
-      :left="windowController?.state.position?.x"
-      :top="windowController?.state.position?.y"
+      :width="windowController?.size.width"
+      :height="windowController?.size.height"
+      :min-height="windowController?.size.minHeight"
+      :max-width="windowController?.size.maxWidth"
+      :max-height="windowController?.size.maxHeight"
+      :left="windowController?.position?.x"
+      :top="windowController?.position?.y"
       :active="windowController?.isResizable ? undefined : []"
       @drag:start="onWindowDragStart"
       @drag:move="onWindowDragMove"
@@ -128,7 +128,7 @@ const classes = computed(() => {
       @resize:start="onWindowResizeStart"
       @resize:move="onWindowResizeMove"
       @resize:end="onWindowResizeEnd"
-      :style="{zIndex: windowController?.state.position?.z}"
+      :style="{zIndex: windowController?.position?.z}"
       :drag-selector="windowController?.isDraggable ? '.owd-window-nav__draggable' : '.owd-window-nav__draggable-none'"
       @pointerdown="onWindowPointerDown"
   >

package/runtime/composables/useTerminalManager.ts

@@ -1,3 +1,7 @@
+import {TerminalManager} from "../core/managers/TerminalManager";
+
+const terminalManager = new TerminalManager()
+
 export function useTerminalManager() {
-    // todo reimplement index of applications cmds
+    return terminalManager
 }

package/runtime/core/controllers/ApplicationController.ts

@@ -2,6 +2,7 @@ import {nanoid} from "nanoid";
 import {WindowController} from "./WindowController";
 import {useApplicationManager} from "../../composables/useApplicationManager"
 import {useApplicationState} from "../../composables/useApplicationState"
+import {useTerminalManager} from "../../composables/useTerminalManager"
 import {useDesktopManager} from "../../composables/useDesktopManager"
 import {debugLog, debugError} from "../../utils/utilsDebug"
 import {useDesktopWorkspaceStore} from "../../stores/storeDesktopWorkspace"
@@ -10,6 +11,7 @@ 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
     public readonly config
@@ -24,6 +26,7 @@ export class ApplicationController implements IApplicationController {
         config: ApplicationConfig
     ) {
         this.applicationManager = useApplicationManager()
+        this.terminalManager = useTerminalManager()
         this.desktopManager = useDesktopManager()
 
         this.id = id
@@ -32,6 +35,9 @@ export class ApplicationController implements IApplicationController {
     }
 
     public async initApplication(): Promise<void> {
+
+        // provides
+
         // set as default app for specific purposes
         // todo improve this and move it in a store
         if (this.config.provides) {
@@ -48,20 +54,34 @@ export class ApplicationController implements IApplicationController {
             }
         }
 
+        // terminal
+
+        if (this.config.commands) {
+            for (const commandKey of Object.keys(this.config.commands)) {
+                this.terminalManager.addCommand({
+                    applicationId: this.id,
+                    name: commandKey
+                })
+            }
+        }
+
+        // store
+
         if (this.store.$persistedState) {
             await this.store.$persistedState.isReady()
         }
 
         // set default meta values
-        this.store.meta = this.config.meta ?? undefined
+        this.store.meta = this.config.meta ?? {}
+
+        // restore application state
+        await this.restoreApplication()
 
         // once app is defined, always run "onReady"
         if (typeof this.config.onReady === 'function') {
+            // todo transform in hook
             this.config.onReady(this)
         }
-
-        // restore application state
-        await this.restoreApplication()
     }
 
     /**
@@ -70,6 +90,7 @@ export class ApplicationController implements IApplicationController {
      */
     public async restoreApplication() {
         if (typeof this.config.onRestore === 'function') {
+            // todo transform in hook
             await this.config.onRestore(this)
         }
 
@@ -203,6 +224,6 @@ export class ApplicationController implements IApplicationController {
     // commands
 
     async execCommand(command: string): Promise<CommandOutput | void> {
-        await this.applicationManager.execAppCommand(this.id, command)
+        return this.applicationManager.execAppCommand(this.id, command)
     }
 }

package/runtime/core/controllers/WindowController.ts

@@ -59,6 +59,7 @@ export class WindowController implements IWindowController {
     ) {
         this.application = application
         this.model = model
+
         this.storedState = windowStoredState
 
         this.setConfig(windowConfig)
@@ -119,6 +120,26 @@ export class WindowController implements IWindowController {
         if (typeof config.destroyable !== 'undefined') {
             this.config.destroyable = config.destroyable
         }
+
+        const DEFAULT_OVERRIDABLE = {
+            draggable: true,
+            resizable: false,
+            position: false,
+            size: false,
+            maximized: false,
+            destroyable: false,
+            minimizable: false,
+            maximizable: false,
+        }
+
+        DEFAULT_OVERRIDABLE.position = DEFAULT_OVERRIDABLE.draggable
+        DEFAULT_OVERRIDABLE.size = DEFAULT_OVERRIDABLE.resizable
+        DEFAULT_OVERRIDABLE.maximized = DEFAULT_OVERRIDABLE.maximizable
+
+        this.config.overridable = {
+            ...DEFAULT_OVERRIDABLE,
+            ...(config.overridable || {})
+        }
     }
 
     // state
@@ -128,17 +149,20 @@ export class WindowController implements IWindowController {
     }
 
     private restoreState() {
-        if (!this.state.pinned) this.state.pinned = this.config.pinned
-        if (!this.state.position) this.state.position = deepClone(this.config.position)
+        const overridable = this.config.overridable || {}
 
-        if (!this.state.minimizable) this.state.minimizable = this.config.minimizable
-        if (!this.state.maximized) this.state.maximized = this.config.maximized
-        if (!this.state.destroyable) this.state.destroyable = this.config.destroyable
-        if (!this.state.draggable) this.state.draggable = this.config.draggable
-        if (!this.state.resizable) this.state.resizable = this.config.resizable
+        for (const key in overridable) {
+            if (overridable[key as keyof typeof overridable]) {
+                const stateKey = key as keyof WindowState
 
-        if (!this.state.size) {
-            this.state.size = deepClone(this.config.size)
+                if (typeof this.state[stateKey] === 'undefined') {
+                    if (typeof this.config[stateKey] === 'object') {
+                        this.state[stateKey] = deepClone(this.config[stateKey])
+                    } else {
+                        this.state[stateKey] = !!this.config[stateKey]
+                    }
+                }
+            }
         }
     }
 
@@ -210,54 +234,30 @@ export class WindowController implements IWindowController {
         return this.application.config.icon
     }
 
-    // sizes
-
-    get width() {
-        if (typeof this.state.size?.width === 'undefined') {
-            return this.config.size.width
-        }
-
-        return this.state.size.width
-    }
-
-    get maxWidth() {
-        if (typeof this.state.size?.maxWidth === 'undefined') {
-            return this.config.size.maxWidth
-        }
-
-        return this.state.size.maxWidth
-    }
-
-    get minWidth() {
-        if (typeof this.state.size?.minWidth === 'undefined') {
-            return this.config.size.minWidth
-        }
-
-        return this.state.size.minWidth
-    }
+    // position
 
-    get height() {
-        if (typeof this.state.size?.height === 'undefined') {
-            return this.config.size.height
+    get position() {
+        if (typeof this.state.position === 'undefined') {
+            return this.config.position
         }
 
-        return this.state.size.height
+        return this.state.position
     }
 
-    get maxHeight() {
-        if (typeof this.state.size?.maxHeight === 'undefined') {
-            return this.config.size.maxHeight ?? 600
-        }
+    // sizes
 
-        return this.state.size.maxHeight
-    }
+    get size() {
+        const stateSize = this.state.size || {}
+        const configSize = this.config.size || {}
 
-    get minHeight() {
-        if (typeof this.state.size?.minHeight === 'undefined') {
-            return this.config.size.minHeight
+        return {
+            width: typeof stateSize.width !== 'undefined' ? stateSize.width : configSize.width,
+            height: typeof stateSize.height !== 'undefined' ? stateSize.height : configSize.height,
+            minWidth: typeof stateSize.minWidth !== 'undefined' ? stateSize.minWidth : configSize.minWidth,
+            maxWidth: typeof stateSize.maxWidth !== 'undefined' ? stateSize.maxWidth : configSize.maxWidth,
+            minHeight: typeof stateSize.minHeight !== 'undefined' ? stateSize.minHeight : configSize.minHeight,
+            maxHeight: typeof stateSize.maxHeight !== 'undefined' ? stateSize.maxHeight : (configSize.maxHeight ?? 600),
         }
-
-        return this.state.size.minHeight
     }
 
     private setSize(data: { width: number, height: number}) {
@@ -272,11 +272,11 @@ export class WindowController implements IWindowController {
     // minimize
 
     get isMinimizable() {
-        if (typeof this.state.minimizable === 'undefined') {
-            return !!this.config.minimizable
+        if (this.config.overridable?.minimizable) {
+            return !!this.state.minimizable
         }
 
-        return this.state.minimizable
+        return !!this.config.minimizable
     }
 
     private minimize() {
@@ -304,11 +304,11 @@ export class WindowController implements IWindowController {
     }
 
     get isMaximized() {
-        if (typeof this.state.maximized === 'undefined') {
-            return !!this.config.maximized
+        if (this.config.overridable?.maximized) {
+            return !!this.state.maximized
         }
 
-        return this.state.maximized
+        return !!this.config.maximized
     }
 
     private toggleMaximize() {
@@ -341,7 +341,11 @@ export class WindowController implements IWindowController {
     // destroy
 
     get isDestroyable() {
-        return !!this.state.destroyable
+        if (this.config.overridable?.destroyable) {
+            return !!this.state.destroyable
+        }
+
+        return !!this.config.destroyable
     }
 
     private destroy() {
@@ -356,12 +360,20 @@ export class WindowController implements IWindowController {
 
     // draggable
     get isDraggable() {
-        return !!this.state.draggable
+        if (this.config.overridable?.draggable) {
+            return !!this.state.draggable
+        }
+
+        return !!this.config.draggable
     }
 
     // resizable
     get isResizable() {
-        return !!this.state.resizable
+        if (this.config.overridable?.resizable) {
+            return !!this.state.resizable
+        }
+
+        return !!this.config.resizable
     }
 
     // workspace

package/runtime/core/managers/ApplicationManager.ts

@@ -69,7 +69,7 @@ export class ApplicationManager implements IApplicationManager {
      * @param id
      * @param entryKey
      */
-    public async launchAppEntry(id: string, entryKey: string) {
+    public async launchAppEntry(id: string, entryKey: string): Promise<IApplicationController | undefined | void> {
         if (!this.isAppDefined(id)) {
             throw Error(`App "${id}" is not defined`);
         }
@@ -91,7 +91,7 @@ export class ApplicationManager implements IApplicationManager {
      * @param id
      * @param command
      */
-    public async execAppCommand(id: string, command: string) {
+    public async execAppCommand(id: string, command: string): Promise<CommandOutput> {
         if (!this.isAppDefined(id)) {
             throw Error(`App "${id}" is not defined`);
         }
@@ -106,12 +106,11 @@ export class ApplicationManager implements IApplicationManager {
         }
 
         const commandFn: any = applicationController.config.commands![baseCommand]
-
-        commandFn(applicationController, commandSplit.slice(1))
+        const commandOutput = await commandFn(applicationController, commandSplit.slice(1))
 
         applicationController.setRunning(true)
 
-        return applicationController;
+        return commandOutput;
     }
 
     /**
@@ -149,7 +148,7 @@ export class ApplicationManager implements IApplicationManager {
                     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,
+                    visibility: entry.visibility ?? 'primary',
                     command: entry.command
                 })
             }

package/runtime/core/managers/DesktopManager.ts

@@ -2,6 +2,7 @@ import {deepMerge} from "../../utils/utilsCommon"
 
 export class DesktopManager {
     public config: DesktopConfig = {} as DesktopConfig
+
     private defaultApps: DefaultAppsConfig = {}
 
     constructor() {
@@ -30,7 +31,7 @@ export class DesktopManager {
 
     private loadDefaultAppsFromConfig() {
         if (this.config.defaultApps) {
-            this.defaultApps = { ...this.config.defaultApps }
+            this.defaultApps = {...this.config.defaultApps}
         }
     }
 }

package/runtime/core/managers/TerminalManager.ts

@@ -0,0 +1,42 @@
+import {useApplicationManager} from "../../composables/useApplicationManager"
+import {debugLog} from "../../utils/utilsDebug"
+
+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)) {
+            throw new Error(`Command "${name}" not found`)
+        }
+
+        const cmd = this.commands.get(name)!
+
+        return applicationManager.execAppCommand(cmd.applicationId, input)
+    }
+}

package/runtime/utils/utilsApp.ts

@@ -1,3 +1,5 @@
+import type {Nuxt} from "@nuxt/schema";
+
 export function normalizeApplicationConfig(config: ApplicationConfig): ApplicationConfig {
     const normalizedEntries: Record<string, ApplicationEntry> = {}
 
@@ -20,12 +22,12 @@ export function normalizeApplicationConfig(config: ApplicationConfig): Applicati
     }
 }
 
-export function registerTailwindPath(nuxt, path: string) {
-    nuxt.options.appConfig = nuxt.options.appConfig || {}
-    nuxt.options.appConfig.owd = nuxt.options.appConfig.owd || {}
-    nuxt.options.appConfig.owd.tailwindPaths = nuxt.options.appConfig.owd.tailwindPaths || []
+export function registerTailwindPath(nuxt: Nuxt, path: string) {
+    nuxt.options.runtimeConfig = nuxt.options.runtimeConfig || {}
+    nuxt.options.runtimeConfig.owd = nuxt.options.runtimeConfig.owd || {}
+    nuxt.options.runtimeConfig.owd.tailwindPaths = nuxt.options.runtimeConfig.owd.tailwindPaths || []
 
-    if (!nuxt.options.appConfig.owd.tailwindPaths.includes(path)) {
-        nuxt.options.appConfig.owd.tailwindPaths.push(path)
+    if (!nuxt.options.runtimeConfig.owd.tailwindPaths.includes(path)) {
+        nuxt.options.runtimeConfig.owd.tailwindPaths.push(path)
     }
 }

package/runtime/utils/utilsCommon.ts

@@ -1,7 +1,30 @@
-export function deepClone(obj: any) {
+export function deepClone<T>(obj: T): T {
     return JSON.parse(JSON.stringify(obj))
 }
 
+export function deepEqual(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!obj2.hasOwnProperty(key)) {
+            return false;
+        }
+        if (typeof obj1[key] === 'object' && typeof obj2[key] === 'object') {
+            if (!deepEqual(obj1[key], obj2[key])) {
+                return false;
+            }
+        } else {
+            if (obj1[key] !== obj2[key]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 export function deepMerge<T>(target: T, source: Partial<T>): T {
     function isObject(value: any): value is Record<string, any> {
         return (

package/runtime/utils/utilsDesktop.ts

@@ -7,7 +7,5 @@ export function defineDesktopApp(config: ApplicationConfig) {
 }
 
 export function defineDesktopConfig(config: DesktopConfig) {
-    const desktopManager = useDesktopManager()
-    desktopManager.setConfig(config)
-    return true
+    return config
 }

package/runtime/utils/utilsWindow.ts

@@ -7,6 +7,7 @@ export function handleWindowControllerProps(windowController: any) {
 
     return {
         ...windowController,
+        ...windowController.config,
         state: {
             ...windowController.config,
         },

package/types/owd.d.ts

@@ -11,12 +11,12 @@ interface IApplicationManager {
 
     get appsByCategory(): { [category: string]: IApplicationController[] }
 
-    defineApp(appId: string, config: ApplicationConfig): Promise<IApplicationController>
+    defineApp(id: string, config: ApplicationConfig): Promise<IApplicationController>
 
     closeApp(id: string): void
 
-    launchAppEntry(appId: string, entry: string): Promise<IApplicationController | undefined>
-    execAppCommand(appId: string, command: string): Promise<IApplicationController | undefined>
+    launchAppEntry(id: string, entry: string): Promise<IApplicationController | undefined | void>
+    execAppCommand(id: string, command: string): Promise<CommandOutput | void>
 
     isAppDefined(id: string): boolean
 
@@ -56,7 +56,7 @@ interface ApplicationConfigProvide {
 
 type IApplicationMeta = { [key: string]: any }
 
-interface sIApplicationController {
+interface IApplicationController {
     id: string
     config: ApplicationConfig
 
@@ -81,7 +81,7 @@ interface sIApplicationController {
 
     closeAllWindows(): void
 
-    execCommand(command: string)
+    execCommand(command: string): Promise<CommandOutput | void>
 
     get windowsOpened(): Reactive<Map<string, IWindowController>>
 }
@@ -102,17 +102,7 @@ interface IWindowController {
     get icon(): string | undefined
 
     // sizes
-    get width(): WindowSizeValue
-
-    get maxWidth(): WindowSizeValue
-
-    get minWidth(): WindowSizeValue
-
-    get height(): WindowSizeValue
-
-    get maxHeight(): WindowSizeValue
-
-    get minHeight(): WindowSizeValue
+    get size(): WindowSize
 
     // minimize
     get isMinimizable(): boolean
@@ -170,7 +160,6 @@ interface WindowConfig {
     title?: string
     category?: string
     icon?: string
-    pinned?: boolean
 
     component?: Raw<Component>
 
@@ -195,6 +184,8 @@ interface WindowConfig {
 
     // draggable
     resizable?: boolean
+
+    overridable?: Partial<Record<'position' | 'size' | 'maximized' | 'draggable' | 'resizable' | 'destroyable' | 'minimizable', boolean>>
 }
 
 interface WindowStoredState {
@@ -212,7 +203,6 @@ interface WindowState {
     createdAt: number
 
     category?: string
-    pinned?: boolean
     workspace: string
 
     // position
@@ -286,13 +276,17 @@ interface IDesktopManager {
 }
 
 interface DesktopConfig {
-    name?: string
-    compatibility?: string
+    theme?: string
+    modules?: string[]
     apps?: string[]
+
+    name?: string
     defaultApps?: DefaultAppsConfig
     features?: string[]
+
     systemBar?: DesktopSystemBarConfig
     dockBar?: DesktopDockBarConfig
+    workspaces?: DesktopWorkspacesConfig
 }
 
 interface DesktopWindowsConfig {
@@ -310,11 +304,15 @@ interface DesktopSystemBarConfig {
     startButton?: boolean
 }
 
+interface DesktopWorkspacesConfig {
+    enabled?: boolean
+}
+
 // TERMINAL
 
-interface CommandFn {
-    fn: (app: IApplicationController, args: string[]) => string | CommandOutput | void
-    app: IApplicationController
+type TerminalCommand = {
+    name: string
+    applicationId: string
 }
 
 interface CommandOutput {

package/types/index.d.ts

@@ -1,9 +0,0 @@
-declare module 'nuxt/schema' {
-  interface AppConfig {
-    owd: {
-      apps: string[]
-    }
-  }
-}
-
-export {}