Sync version numbers across all package files

Update Cargo.toml and tauri.conf.json to version 0.1.2 to match package.json

.github/workflows/build.yml

@@ -0,0 +1,228 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+    tags-ignore:
+      - '**'
+  pull_request:
+    branches:
+      - main
+      - develop
+  workflow_dispatch:
+
+jobs:
+  build-desktop:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: 'macos-latest'
+            args: '--target aarch64-apple-darwin'
+          - platform: 'macos-latest'
+            args: '--target x86_64-apple-darwin'
+          - platform: 'ubuntu-22.04'
+            args: ''
+          - platform: 'windows-latest'
+            args: ''
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
+
+      - name: Install dependencies (Ubuntu)
+        if: matrix.platform == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Install frontend dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build Tauri app
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: ${{ matrix.args }}
+
+      - name: Upload artifacts (macOS)
+        if: matrix.platform == 'macos-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: macos-${{ contains(matrix.args, 'aarch64') && 'aarch64' || 'x86_64' }}
+          path: |
+            src-tauri/target/*/release/bundle/dmg/*.dmg
+            src-tauri/target/*/release/bundle/macos/*.app
+
+      - name: Upload artifacts (Ubuntu)
+        if: matrix.platform == 'ubuntu-22.04'
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux
+          path: |
+            src-tauri/target/release/bundle/deb/*.deb
+            src-tauri/target/release/bundle/appimage/*.AppImage
+            src-tauri/target/release/bundle/rpm/*.rpm
+
+      - name: Upload artifacts (Windows)
+        if: matrix.platform == 'windows-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows
+          path: |
+            src-tauri/target/release/bundle/msi/*.msi
+            src-tauri/target/release/bundle/nsis/*.exe
+
+  build-android:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install Rust Android targets
+        run: |
+          rustup target add aarch64-linux-android
+          rustup target add armv7-linux-androideabi
+          rustup target add i686-linux-android
+          rustup target add x86_64-linux-android
+
+      - name: Setup NDK
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r26d
+        id: setup-ndk
+
+      - name: Setup Android NDK environment for OpenSSL
+        run: |
+          echo "ANDROID_NDK_HOME=${{ steps.setup-ndk.outputs.ndk-path }}" >> $GITHUB_ENV
+          echo "NDK_HOME=${{ steps.setup-ndk.outputs.ndk-path }}" >> $GITHUB_ENV
+
+          # Add all Android toolchains to PATH for OpenSSL cross-compilation
+          echo "${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin" >> $GITHUB_PATH
+
+          # Set CC, AR, RANLIB for each target
+          echo "CC_aarch64_linux_android=aarch64-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_aarch64_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_aarch64_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_armv7_linux_androideabi=armv7a-linux-androideabi24-clang" >> $GITHUB_ENV
+          echo "AR_armv7_linux_androideabi=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_armv7_linux_androideabi=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_i686_linux_android=i686-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_i686_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_i686_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_x86_64_linux_android=x86_64-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_x86_64_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_x86_64_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+      - name: Install build dependencies for OpenSSL
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y perl make
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Install frontend dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Setup Keystore (if secrets available)
+        env:
+          ANDROID_KEYSTORE: ${{ secrets.ANDROID_KEYSTORE }}
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
+        run: |
+          if [ -n "$ANDROID_KEYSTORE" ]; then
+            echo "$ANDROID_KEYSTORE" | base64 -d > $HOME/keystore.jks
+            echo "ANDROID_KEYSTORE_PATH=$HOME/keystore.jks" >> $GITHUB_ENV
+            echo "ANDROID_KEYSTORE_PASSWORD=$ANDROID_KEYSTORE_PASSWORD" >> $GITHUB_ENV
+            echo "ANDROID_KEY_ALIAS=$ANDROID_KEY_ALIAS" >> $GITHUB_ENV
+            echo "ANDROID_KEY_PASSWORD=$ANDROID_KEY_PASSWORD" >> $GITHUB_ENV
+            echo "Keystore configured for signing"
+          else
+            echo "No keystore configured, building unsigned APK"
+          fi
+
+      - name: Build Android APK and AAB (unsigned if no keystore)
+        run: pnpm tauri android build
+
+      - name: Upload Android artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: android
+          path: |
+            src-tauri/gen/android/app/build/outputs/apk/**/*.apk
+            src-tauri/gen/android/app/build/outputs/bundle/**/*.aab

.github/workflows/release.yml

@@ -0,0 +1,251 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  create-release:
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    outputs:
+      release_id: ${{ steps.create-release.outputs.release_id }}
+      upload_url: ${{ steps.create-release.outputs.upload_url }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Get version
+        run: echo "PACKAGE_VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
+
+      - name: Create release
+        id: create-release
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data } = await github.rest.repos.createRelease({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              tag_name: `v${process.env.PACKAGE_VERSION}`,
+              name: `haex-hub v${process.env.PACKAGE_VERSION}`,
+              body: 'Take a look at the assets to download and install this app.',
+              draft: true,
+              prerelease: false
+            })
+            core.setOutput('release_id', data.id)
+            core.setOutput('upload_url', data.upload_url)
+            return data.id
+
+  build-desktop:
+    needs: create-release
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: 'macos-latest'
+            args: '--target aarch64-apple-darwin'
+          - platform: 'macos-latest'
+            args: '--target x86_64-apple-darwin'
+          - platform: 'ubuntu-22.04'
+            args: ''
+          - platform: 'windows-latest'
+            args: ''
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
+
+      - name: Install dependencies (Ubuntu)
+        if: matrix.platform == 'ubuntu-22.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Install frontend dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build and release Tauri app
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          releaseId: ${{ needs.create-release.outputs.release_id }}
+          args: ${{ matrix.args }}
+
+  build-android:
+    needs: create-release
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install Rust Android targets
+        run: |
+          rustup target add aarch64-linux-android
+          rustup target add armv7-linux-androideabi
+          rustup target add i686-linux-android
+          rustup target add x86_64-linux-android
+
+      - name: Setup NDK
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r26d
+        id: setup-ndk
+
+      - name: Setup Android NDK environment for OpenSSL
+        run: |
+          echo "ANDROID_NDK_HOME=${{ steps.setup-ndk.outputs.ndk-path }}" >> $GITHUB_ENV
+          echo "NDK_HOME=${{ steps.setup-ndk.outputs.ndk-path }}" >> $GITHUB_ENV
+
+          # Add all Android toolchains to PATH for OpenSSL cross-compilation
+          echo "${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin" >> $GITHUB_PATH
+
+          # Set CC, AR, RANLIB for each target
+          echo "CC_aarch64_linux_android=aarch64-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_aarch64_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_aarch64_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_armv7_linux_androideabi=armv7a-linux-androideabi24-clang" >> $GITHUB_ENV
+          echo "AR_armv7_linux_androideabi=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_armv7_linux_androideabi=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_i686_linux_android=i686-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_i686_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_i686_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+          echo "CC_x86_64_linux_android=x86_64-linux-android24-clang" >> $GITHUB_ENV
+          echo "AR_x86_64_linux_android=llvm-ar" >> $GITHUB_ENV
+          echo "RANLIB_x86_64_linux_android=llvm-ranlib" >> $GITHUB_ENV
+
+      - name: Install build dependencies for OpenSSL
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y perl make
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: src-tauri
+
+      - name: Install frontend dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Setup Keystore (required for release)
+        run: |
+          echo "${{ secrets.ANDROID_KEYSTORE }}" | base64 -d > $HOME/keystore.jks
+          echo "ANDROID_KEYSTORE_PATH=$HOME/keystore.jks" >> $GITHUB_ENV
+          echo "ANDROID_KEYSTORE_PASSWORD=${{ secrets.ANDROID_KEYSTORE_PASSWORD }}" >> $GITHUB_ENV
+          echo "ANDROID_KEY_ALIAS=${{ secrets.ANDROID_KEY_ALIAS }}" >> $GITHUB_ENV
+          echo "ANDROID_KEY_PASSWORD=${{ secrets.ANDROID_KEY_PASSWORD }}" >> $GITHUB_ENV
+
+      - name: Build Android APK and AAB (signed)
+        run: pnpm tauri android build
+
+      - name: Upload Android artifacts to Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release upload ${{ github.ref_name }} \
+            src-tauri/gen/android/app/build/outputs/apk/universal/release/app-universal-release.apk \
+            src-tauri/gen/android/app/build/outputs/bundle/universalRelease/app-universal-release.aab \
+            --clobber
+
+  publish-release:
+    permissions:
+      contents: write
+    runs-on: ubuntu-22.04
+    needs: [create-release, build-desktop, build-android]
+
+    steps:
+      - name: Publish release
+        id: publish-release
+        uses: actions/github-script@v7
+        env:
+          release_id: ${{ needs.create-release.outputs.release_id }}
+        with:
+          script: |
+            github.rest.repos.updateRelease({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              release_id: process.env.release_id,
+              draft: false,
+              prerelease: false
+            })

.gitignore

@@ -25,3 +25,7 @@ dist-ssr
 .nuxt
 src-tauri/target
 nogit*
+.claude
+.output
+target
+CLAUDE.md

README.md

@@ -1,81 +1,144 @@
-# HaexHub - The European "Everything App"
+# 🧩 HaexHub – The European “Everything App”
 
-## Vision
+## 🌍 Vision
 
-Today, we undoubtedly find ourselves in the computer age. Almost everyone owns at least one computer, often even more. Most probably have at least a smartphone and a standard PC. On each of these devices (Desktop PC, Laptop, Tablet, Smartphone) and systems (Windows, macOS, Linux (all flavors), Android, iOS), there are various programs and data, which can be highly individual and sensitive. Unfortunately, interoperability between these devices and systems often proves difficult, sometimes even impossible, for a multitude of reasons. On one hand, there are the system providers themselves (like Microsoft, Apple, Google), who often design their systems to make it as easy as possible for users to enter their ecosystems, but place many hurdles in the way when users wish to leave again. The golden cage, as we say in Germany, or walled garden. However, it's not just the system providers per se who make cross-device and cross-system work difficult. Another problem lies with the software manufacturers/providers. Since it is already challenging and above all resource-intensive (time, money, and technical know-how) to provide a good and "secure" product for one device class and/or system, it's not uncommon for a program to be developed (initially) for only one platform. So, there might be a program for Windows or Apple, but not for Linux, or only in one distribution/package format. Or there might be an app for iOS and/or Android, but not for the PC. This is partly due to the fact that it would simply be too complex to develop and, especially, maintain a product for multiple systems and devices (simultaneously). This effort is almost insurmountable, particularly for startups, small businesses, and individual open-source developers working on their passion projects in their spare time.
+We are living in the **computer age** — nearly everyone owns multiple devices: a smartphone, a laptop, perhaps even a desktop PC or tablet.  
-Let's not even start talking about application distribution. For each platform, you end up with a separate build pipeline that builds, tests, signs, packages the application into the appropriate format (msi, exe, deb, flatpak, snap, AppImage, Apk, etc.), and delivers it to the corresponding store (AppStore, PlayStore, Windows Store, and the various repositories of Linux distributions). This is a huge cascade of tasks that especially causes problems for small companies (at least if you want to serve ALL platforms simultaneously).
+Each of these runs its own **operating system** — Windows, macOS, Linux, Android, iOS — and hosts a unique mix of **apps and data**.
-Wouldn't it be nice if there were a simple(r) way for developers to develop and build their application just once and then be able to serve ALL\* devices and systems? PWAs were already on the right track, but there is often a lack of more in-depth access to system resources, such as file or console access.
-HaexHub gives any web application/PWA superpowers.
-Extensions can be used to add any functions to HaexHub, whereby almost any access to the underlying system is possible, provided that the necessary authorizations have been granted by the user beforehand.
 
-\*In principle, the approach presented here allows an application to run on all devices and systems. However, some applications might still only be usable on certain devices or systems. For example, if an application absolutely requires an NFC device, which is typically not found on a desktop PC, then this application will probably only work on mobile devices. Or if an application requires system-specific interfaces or programs, such as the Registry on Windows or systemd on Linux, then this application will naturally only work where these dependencies are found. However, developers who create their applications without such dependencies can immediately serve all devices and systems.
+Unfortunately, **interoperability** between these devices is often poor or even impossible.  
+The reasons are many:
 
-## Enter HaexHub
+- **Platform lock-in**: Vendors like Microsoft, Apple, or Google design systems that make it easy to _enter_ their ecosystem but difficult to _leave_.
+- **Fragmented software development**: Developers face high technical and financial hurdles to support multiple platforms at once.
 
-HaexHub provides a framework that makes it incredibly easy for the community and any developer to build extensions (web applications), which can then be easily integrated into HaexHub by users. Each extension is essentially a web application that can be loaded, executed, customized, and deleted at runtime. Each extension is confined within an IFrame, communicating with HaexHub via APIs using postMessage. HaexHub, in turn, checks these requests for the necessary permissions, executes or rejects the command, and returns a possible response to the caller – ideally, the correct result.
+Creating and maintaining one secure, high-quality app for _all_ systems can be almost impossible — especially for small teams, startups, and indie developers.
-Since these are purely web applications, they are initially subject to the same limitations as any other web application in any "normal" browser worldwide. Fun Fact: Extensions in HaexHub are even more restricted than that. While a "normal" web application can, for example, load additional resources (JavaScript, CSS, images, ads) (assuming CORS allows it), this is initially not possible with a HaexHub extension. Everything the extension needs to be able to do must be specified as a permission in a manifest and approved by the user before (potentially) dangerous actions are executed on the host. And loading external resources is already considered such a risk from Tauri's (and my) perspective, as it can severely compromise the user's privacy.
-With the appropriate permissions, however, an extension can do almost anything possible on a computer. Thus, unlike a "normal" web application, an extension can directly access the host's file system, execute other applications and commands, make/manipulate/block web requests, or access the SQLite database. To use these interfaces, each extension must declare the corresponding permissions in a manifest, which must then be approved by the user. Otherwise, no access to the host system is possible. Extensions can be added and removed at runtime. Since the extension runs in an IFrame, it cannot cause much damage without the appropriate permissions. It would be a pure web application where routing within the application is possible (WebHistoryHash). However, as soon as it tries to load external resources, regardless of whether they are local from the host or from any server on the World Wide Web, the extension is on its own without permission.
-Technically, for example, it would pose no problem to make the host system's shell available to extensions. This could give Visual Studio Code in the browser superpowers. While a web version of Visual Studio Code already exists, its usability is limited. For instance, it's not possible to directly access the shell or the file system, which significantly hinders file management. And since no commands or applications can be executed on the host, it's (unfortunately) practically useless for developers. Visual Studio Code as a HaexHub extension could be used like a native application. And thanks to HaexHub's permission concept, it can be controlled with fine granularity which extension is allowed to execute what and how, and what is not. An extension with such power over the host, which can be both advantageous and disadvantageous for the user, should naturally be handled with particular care. It would probably not be a good idea to grant this permission to any advertising and data tracking services.
 
-The framework itself provides a platform that will be available on all common devices (Desktop PC, Laptop, Tablet, Smartphone) and systems (Windows, macOS, Linux (all flavors), Android, iOS). All extensions can then be used on all supported devices and systems (provided there are no dependencies in the extension that are only available on specific devices or systems, like NFC, Google Pay, etc.).
+And then there’s **distribution**: each platform requires its own build, packaging, signing, and publishing process.  
-All user and extension data can be securely stored and used in the locally encrypted SQLite database. To enable comfortable use of the database across multiple devices and systems, there will be a synchronization server that allows the database to be synchronized conflict-free across devices and systems. This server can, of course, also be self-hosted, ensuring the user is never dependent on a single provider.
+What if you could build your app **once** and deploy it **everywhere**?
-Furthermore, the data can be encrypted beforehand, making it unreadable by third parties.
 
-HaexHub is a cross-platform, local-first, open-source application that prioritizes user privacy, security, and digital sovereignty. The goal is for the user to have control over their data at all times and be able to independently decide what they want to disclose to whom. Additionally, they should be able to adjust this decision at any time.
+> **HaexHub** makes that possible — giving every web app or PWA **superpowers**.
-Through the possibility of extensions, HaexHub is also almost infinitely expandable. What Visual Studio Code is for text editors/IDEs, HaexHub will be for (web) applications and even has the potential to become the European counterpart to WeChat (the "everything app"). However, without a central authority controlling everything.
 
-But first things first.
+With HaexHub, developers can extend functionality via **extensions** that run securely inside the app, with carefully controlled permissions for accessing system features (files, shell, database, etc.).
 
-## Technical Foundations
+---
 
-The technical foundation of the project is Tauri. This framework makes it possible to provide native applications for all common devices (Desktops, Laptops, Tablets, Smartphones) and systems (Windows, Linux, macOS, Android, iOS) with the same codebase. Tauri is comparable to Electron (the technical basis for Visual Studio Code, for example), but the applications created with it are significantly smaller because Tauri uses the native rendering engine of the respective platform (WebView2 (Windows), WKWebView (macOS), WebKitGTK (Linux)) and does not bundle a (customized Chromium) browser, as is the case with Electron. Furthermore, Tauri offers significant advantages over Electron in terms of security and resource efficiency. There is also a sophisticated permission system, which effectively shields the frontend from the host. All access to the host system is only possible with the appropriate permission. This permission concept is also used for the (HaexHub) extensions, thereby ensuring the security of third-party extensions as well.
+## 🚀 Enter HaexHub
 
-The project follows a strict local-first approach. This means that HaexHub can fundamentally be used without any form of online account or internet access. The extensions are also stored locally and can be used offline, provided, of course, that the extension itself can function without the internet. A messenger extension will likely make limited sense without internet access. An image viewer or text editor, however, should work fine without the internet.
+HaexHub provides a **framework** for building and running modular, sandboxed **web extensions** — web apps that run in an isolated environment but can communicate securely with the host.
-All user data can be persistently stored and used in a locally encrypted SQLite database, even across extensions, with the appropriate permissions, of course. Unlike many other applications that call themselves local-first, this project implements this approach more consistently. Most applications claiming to be local-first often aren't truly so. The data usually resides (unencrypted) on a backend server and is merely "cached" to varying degrees in the frontend. While this allows these applications to be used offline for a while, the usage is either restricted (read-only in Bitwarden, for example) or the persistence is temporary at best. Most approaches, like this project, use an SQLite (or similar) database in the frontend to achieve offline capability, but this is usually implemented in a browser via IndexedDB or OPFS. Examples include [powersync](https://www.powersync.com/) , [evolu](https://www.evolu.dev/), or [electricSql](https://electric-sql.com/). The problem here is that such persistence is never truly permanent, as the operating system and/or browser can decide when to free up storage. For instance, it's common for Apple to clear the storage of web applications that haven't been used for over a week. As long as the user's data is still present in the backend, this is only moderately tragic, as the "source of truth" residing there can be synchronized back to the frontend at any time. However, this always requires an online account and internet access. Furthermore, with these approaches, the user cannot simply copy their data onto a USB stick and take it with them to use on a completely different computer (perhaps where only intranet is available).
-Moreover, all these approaches are subject to the limitations of the respective browser. The limitation on persistent storage is particularly noteworthy here. All browsers have strict limits, which is why this approach is not suitable for all requirements. Since HaexHub stores data not in the browser, but in a real SQLite database on the hard drive, it is only subject to the hardware limitations of the host system (or USB stick/storage medium).
 
-With HaexHub, all user and extension data can be permanently stored in the local and encrypted database without requiring an online account. However, to make the user's data conveniently and securely available on multiple devices, there will be a synchronization service to synchronize the database state across the user's various devices and systems. The user can, of course, also host this service themselves on their (local) systems or servers. The database state is thus temporarily stored on a (third-party) server and can be synchronized from there with other instances of the local SQLite database. To further enhance data security, the user can also encrypt the data before sending it to the backend, making it unreadable by third parties. This will likely be enabled by default, but it can also be turned off, as there are legitimate use cases where it might be disadvantageous or undesirable. Particularly in corporate or government environments, it could be problematic if all user (employee) data were stored encrypted on the company servers. If the employee becomes unavailable (resignation, accident, death) and their database password (or the encryption key stored in the database) is unknown, there would be no way to access this data.
+Each extension:
-Since this use case should also be considered, backend encryption will be optional.
 
-As HaexHub is ultimately a kind of distributed and federated system, there is no (single) authority that could control everything. Unless the user truly has only one instance of their database (perhaps on a USB stick) and always carries it with them. Part of HaexHub's charm, however, is that the user can have multiple instances of their SQLite database on multiple devices and systems without having to worry about how the correct data (source of truth) gets from A to B and B to A.
+- Runs inside an **IFrame**.
-To make this possible and to synchronize even conflicting data states of the SQLite database, HaexHub uses Conflict-free Replicated Data Types (CRDTs). This will make it possible to merge multiple conflicting data states, even if they are encrypted.
+- Uses **postMessage APIs** to communicate with HaexHub.
+- Declares required **permissions** in a manifest file.
+- Can be added or removed at runtime.
 
-## Extensions
+Without explicit permission, extensions cannot access the file system, network, or external resources — ensuring **privacy and security** by default.  
+Once granted, however, extensions can unlock full desktop-like capabilities:  
+access files, execute commands, or interact with SQLite databases.
 
-The real highlight of HaexHub, however, lies in its extensions. All end-user functionality will ultimately be provided through extensions. There will be (official/core) extensions and third-party extensions. One of the first (official) extensions will be a password manager, for example, but a file synchronization service is also planned.
+Imagine a **web-based VS Code** that can directly access your local shell and file system — something that current web IDEs can’t do.  
-Each extension is essentially just a web application\* loaded into an IFrame. This keeps all extensions well isolated (sandboxed) from the main application (HaexHub) and the user's host system, ensuring the user's security and privacy. Of course, as with any application, a degree of trust must be placed in the extension developer that they are genuinely only doing what they claim to do. HaexHub is ingenious, but it can't perform magic.
+With HaexHub’s permission model, such power is possible, but **always under user control**.
-Each extension must declare the permissions it requires in a manifest, which must then be accepted by the user. This ensures that each extension can only access the resources (file system, web requests, database access, etc.) for which it has the appropriate permissions.
 
-In principle, any (existing) web application could be integrated and run within HaexHub. Technically, each extension is just a web application, but with significantly more capabilities. Traditional web applications are restricted by the (justified) limitations of a browser. For example, a web application cannot simply access the host system's file system or manipulate network traffic. And for good reasons. With HaexHub, however, these limitations do not exist. A (HaexHub) extension can indeed access the file system if it has the corresponding permission. This opens up almost unlimited application possibilities, making the term "everything app" seem not so far-fetched. In a future iteration, a browser and later a payment option (GNU Taler?!) are planned to be added, so it could truly become a fully-fledged counterpart to WeChat. However, these aspects are not considered in the first iteration of the application.
+HaexHub itself is **cross-platform** and runs on:
-By providing extensions, HaexHub can truly be enhanced arbitrarily. Extension developers could use simple tools (Vite application) to immediately provide their functionality for all devices and systems and utilize the provided ecosystem, without the developer having to deal with the peculiarities of each system for development and distribution. (Provided, of course, they don't rely on dependencies that only exist on specific systems or devices).
-Extensions can also access the data of other extensions (e.g., via the SQLite database) and build upon it (with appropriate permission, naturally).
-I want to outline this with a concrete example. The first official extension will be a password manager.
-This will be a Nuxt/Vue application. The password manager's manifest will request permission to create a few tables and to read from and write to them. The extension then provides a nice UI for creating and managing login credentials, similar to existing password managers. Each entry can also be tagged, which could later be used by other extensions.
-For example, entries tagged "E-Mail" could be created, which could then be used by an email client extension to automatically connect to mail servers.
-Any other extension could access specific entries in the password database (or other extensions' data) to easily provide its service.
-But of course, each extension can also create its own tables as needed for its specific use case.
-HaexHub takes care of secure storage and, if configured, conflict-free synchronization.
-Each user can expand their HaexHub with the individual functionality they need. And since all settings for these extensions can be stored in the SQLite database, they can be easily and seamlessly synchronized and used across multiple devices. The user only needs to set up their extensions once on one device and can then use them on all other devices and systems without further action.
 
-Another example of an extension would be file synchronization, which will also be a core extension.
+- 💻 Windows, macOS, Linux
-This extension allows users to easily synchronize their files across different devices and systems. It can be configured on each device which files and folders should be synchronized and how. For instance, one might want to upload pictures and videos from their smartphone to an S3 bucket/Google Drive/Dropbox and their desktop PC. However, one probably doesn't want all pictures from the S3 bucket/Google Drive/Dropbox/Desktop to be synchronized back to the smartphone. All these configurations will again be stored in the SQLite database and, where possible, synchronized across all devices and systems.
+- 📱 Android, iOS
+- 🧠 Desktops, laptops, tablets, smartphones
 
-Further examples of extensions include calendars, (collaborative) document management, contacts, messengers, and in the distant future, a browser and payment service (GNU Taler perhaps?!).
+All user and extension data is stored in a **locally encrypted SQLite database**.  
+To sync across devices, HaexHub can connect to a **synchronization server** — which you can even **self-host** for maximum independence.
 
-\*Fundamentally, any bundler (Vite, Webpack, Rollup, etc.) and any frontend framework (Vue, React, Angular, Svelte, plain HTML) should be usable. The crucial part is that it's a JS bundle. However, initially, the focus will primarily be on Vite and Vue to demonstrate the general feasibility first.
+> 🛡️ HaexHub is built on the principles of **privacy, security, and digital sovereignty**.
 
-## Preperation
+The user is always in control of their data — deciding what to share, and with whom.
 
-install:
+---
 
-- [nodejs/nvm](https://nodejs.org/en/download)
+## 🧠 Technical Foundations
-- [tauri](https://v2.tauri.app/start/prerequisites/)
+
-- [rust](https://v2.tauri.app/start/prerequisites/#rust)
+HaexHub is powered by **[Tauri](https://v2.tauri.app/)** — a secure, efficient framework for building native apps from web technologies.
-- [android-studio](https://developer.android.com/studio?hl=de)
+
-- webkit2gtk + GTK3
+Unlike Electron (used by apps like VS Code), Tauri:
+
+- Uses **native rendering engines** (WebView2, WKWebView, WebKitGTK)
+- Produces **smaller, faster apps**
+- Enforces **strong sandboxing and permission models**
+
+HaexHub builds upon Tauri’s security features, extending them to third-party extensions.
+
+### 🏡 Local-first by Design
+
+HaexHub follows a **strict local-first architecture**:
+
+- Works **offline** without accounts or internet.
+- Stores data locally in **encrypted SQLite**.
+- Uses **CRDTs (Conflict-free Replicated Data Types)** for safe synchronization across devices — even with encrypted data.
+
+Unlike many “local-first” apps, HaexHub doesn’t just cache data in the browser.  
+Your data truly resides **on your disk**, not under a browser’s limited storage policy.
+
+Optionally, HaexHub can sync databases via a backend service — self-hosted or external — with optional **end-to-end encryption**.
+
+---
+
+## 🧩 Extensions
+
+Extensions are the heart of HaexHub.
+
+Everything the user interacts with — from password management to file syncing — will be implemented as **extensions**.
+
+There are two types:
+
+- **Official/Core Extensions**
+- **Third-Party Extensions**
+
+Each extension is a **web app** bundled via your preferred frontend stack:
+
+> Vue, React, Svelte, Angular, Vite, Webpack, Rollup — you name it.
+
+### 🔐 Example: Password Manager
+
+A first official extension will be a **Password Manager**, built with **Vue/Nuxt**:
+
+- Declares database permissions via its manifest.
+- Manages login credentials locally in encrypted SQLite.
+- Can tag entries (e.g. “Email”) for use by other extensions — such as an email client.
+
+### 🗂 Example: File Synchronization
+
+Another planned core extension will handle **file synchronization**:
+
+- Syncs files/folders between devices and cloud providers (e.g. S3, Google Drive, Dropbox).
+- Lets users define sync rules per device.
+- Stores configuration securely in the local database.
+
+### 💬 Future Extensions
+
+- Calendar & Contacts
+- Collaborative document management
+- Messenger
+- Browser & Payment Services (e.g., GNU Taler integration)
+
+With this modular design, HaexHub can evolve into a true **European alternative to WeChat** — but open, federated, and privacy-first.
+
+---
+
+## 🧰 Installation & Setup
+
+### 📦 Prerequisites
+
+Install the following dependencies:
+
+- [Node.js / nvm](https://nodejs.org/en/download)
+- [Tauri](https://v2.tauri.app/start/prerequisites/)
+- [Rust](https://v2.tauri.app/start/prerequisites/#rust)
+- [Android Studio](https://developer.android.com/studio?hl=de)
+- WebKit2GTK + GTK3
+
+#### 🐧 Debian / Ubuntu
 
 ```bash
-# debian/ubuntu
 sudo apt update
 sudo apt install \
   libwebkit2gtk-4.1-dev \
@@ -84,8 +147,9 @@ sudo apt install \
   librsvg2-dev
 ```
 
+#### 🦊 Fedora
+
 ```bash
-# fedora
 sudo dnf install \
   webkit2gtk4.1-devel \
   gtk3-devel \
@@ -93,11 +157,24 @@ sudo dnf install \
   librsvg2-devel
 ```
 
-- port 3003 needs to be open/free or you need to adjust it in `nuxt.config.ts` AND `src-tauri/tauri.conf.json`
+#### ⚙️ Development
 
-```
+Make sure port 3003 is available (or adjust it in `nuxt.config.ts` and `src-tauri/tauri.conf.json`).
+
+```bash
 git clone https://github.com/haexhub/haex-vault.git
 cd haex-vault
-pnpm i
+pnpm install
 pnpm tauri dev
 ```
+
+#### 🧭 Summary
+
+HaexHub aims to:
+
+- Simplify cross-platform app development
+- Empower users with local-first privacy
+- Enable developers to create modular, permissioned extensions
+- Bridge the gap between web and native worlds
+
+HaexHub is the foundation for a decentralized, privacy-friendly, European “everything app.”

nuxt.config.ts

@@ -1,4 +1,4 @@
-//import tailwindcss from '@tailwindcss/vite'
+import { fileURLToPath } from 'node:url'
 
 // https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
@@ -7,7 +7,16 @@ export default defineNuxtConfig({
 
   srcDir: './src',
 
+  alias: {
+    '@bindings': fileURLToPath(
+      new URL('./src-tauri/bindings', import.meta.url),
+    ),
+  },
+
   app: {
+    head: {
+      viewport: 'width=device-width, initial-scale=1.0, viewport-fit=cover',
+    },
     pageTransition: {
       name: 'fade',
     },
@@ -20,7 +29,6 @@ export default defineNuxtConfig({
     '@vueuse/nuxt',
     '@nuxt/icon',
     '@nuxt/eslint',
-    //"@nuxt/image",
     '@nuxt/fonts',
     '@nuxt/ui',
   ],
@@ -33,6 +41,20 @@ export default defineNuxtConfig({
       'pages/**',
       'types/**',
     ],
+    presets: [
+      {
+        from: '@vueuse/gesture',
+        imports: [
+          'useDrag',
+          'useGesture',
+          'useHover',
+          'useMove',
+          'usePinch',
+          'useScroll',
+          'useWheel',
+        ],
+      },
+    ],
   },
 
   css: ['./assets/css/main.css'],
@@ -72,6 +94,8 @@ export default defineNuxtConfig({
       redirectOn: 'root', // recommended
     },
     types: 'composition',
+
+    vueI18n: './i18n.config.ts',
   },
 
   zodI18n: {
@@ -84,8 +108,7 @@ export default defineNuxtConfig({
   runtimeConfig: {
     public: {
       haexVault: {
-        lastVaultFileName: 'lastVaults.json',
+        deviceFileName: 'device.json',
-        instanceFileName: 'instance.json',
         defaultVaultName: 'HaexHub',
       },
     },
@@ -99,7 +122,6 @@ export default defineNuxtConfig({
   },
 
   vite: {
-    //plugins: [tailwindcss()],
     // Better support for Tauri CLI output
     clearScreen: false,
     // Enable environment variables

package.json

@@ -1,65 +1,67 @@
 {
-  "name": "tauri-app",
+  "name": "haex-hub",
   "private": true,
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "scripts": {
     "build": "nuxt build",
     "dev": "nuxt dev",
-    "generate": "nuxt generate",
-    "preview": "nuxt preview",
-    "postinstall": "nuxt prepare",
-    "tauri": "tauri",
-    "tauri:build:debug": "tauri build --debug",
-    "generate:rust-types": "tsx ./src-tauri/database/generate-rust-types.ts",
     "drizzle:generate": "drizzle-kit generate",
     "drizzle:migrate": "drizzle-kit migrate",
-    "eslint:fix": "eslint --fix"
+    "eslint:fix": "eslint --fix",
+    "generate:rust-types": "tsx ./src-tauri/database/generate-rust-types.ts",
+    "generate:ts-types": "cd src-tauri && cargo test",
+    "generate": "nuxt generate",
+    "postinstall": "nuxt prepare",
+    "preview": "nuxt preview",
+    "tauri:build:debug": "tauri build --debug",
+    "tauri": "tauri"
   },
   "dependencies": {
     "@nuxt/eslint": "1.9.0",
     "@nuxt/fonts": "0.11.4",
     "@nuxt/icon": "2.0.0",
-    "@nuxt/ui": "4.0.0",
+    "@nuxt/ui": "4.1.0",
     "@nuxtjs/i18n": "10.0.6",
-    "@pinia/nuxt": "^0.11.1",
+    "@pinia/nuxt": "^0.11.2",
-    "@tailwindcss/vite": "^4.1.10",
+    "@tailwindcss/vite": "^4.1.16",
-    "@tauri-apps/api": "^2.5.0",
+    "@tauri-apps/api": "^2.9.0",
-    "@tauri-apps/plugin-dialog": "^2.2.2",
+    "@tauri-apps/plugin-dialog": "^2.4.2",
-    "@tauri-apps/plugin-fs": "^2.3.0",
+    "@tauri-apps/plugin-fs": "^2.4.4",
-    "@tauri-apps/plugin-http": "2.5.2",
     "@tauri-apps/plugin-notification": "2.3.1",
-    "@tauri-apps/plugin-opener": "^2.3.0",
+    "@tauri-apps/plugin-opener": "^2.5.2",
-    "@tauri-apps/plugin-os": "^2.2.2",
+    "@tauri-apps/plugin-os": "^2.3.2",
-    "@tauri-apps/plugin-sql": "2.3.0",
+    "@tauri-apps/plugin-store": "^2.4.1",
-    "@tauri-apps/plugin-store": "^2.2.1",
     "@vueuse/components": "^13.9.0",
-    "@vueuse/core": "^13.4.0",
+    "@vueuse/core": "^13.9.0",
-    "@vueuse/nuxt": "^13.4.0",
+    "@vueuse/gesture": "^2.0.0",
-    "drizzle-orm": "^0.44.2",
+    "@vueuse/nuxt": "^13.9.0",
-    "eslint": "^9.34.0",
+    "drizzle-orm": "^0.44.7",
-    "fuse.js": "^7.1.0",
+    "eslint": "^9.38.0",
-    "nuxt": "^4.0.3",
+    "nuxt-zod-i18n": "^1.12.1",
-    "nuxt-zod-i18n": "^1.12.0",
+    "swiper": "^12.0.3",
-    "tailwindcss": "^4.1.10",
+    "tailwindcss": "^4.1.16",
-    "vue": "^3.5.20",
+    "vue": "^3.5.22",
-    "vue-router": "^4.5.1",
+    "vue-router": "^4.6.3",
-    "zod": "4.1.5"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@iconify/json": "^2.2.351",
+    "@iconify-json/hugeicons": "^1.2.17",
+    "@iconify-json/lucide": "^1.2.71",
+    "@iconify/json": "^2.2.401",
     "@iconify/tailwind4": "^1.0.6",
     "@libsql/client": "^0.15.15",
-    "@tauri-apps/cli": "^2.5.0",
+    "@tauri-apps/cli": "^2.9.1",
-    "@types/node": "^24.6.2",
+    "@types/node": "^24.9.1",
     "@vitejs/plugin-vue": "6.0.1",
-    "@vue/compiler-sfc": "^3.5.17",
+    "@vue/compiler-sfc": "^3.5.22",
-    "drizzle-kit": "^0.31.2",
+    "drizzle-kit": "^0.31.5",
-    "globals": "^16.2.0",
+    "globals": "^16.4.0",
+    "nuxt": "^4.2.0",
     "prettier": "3.6.2",
     "tsx": "^4.20.6",
-    "tw-animate-css": "^1.3.8",
+    "tw-animate-css": "^1.4.0",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "vite": "7.1.3",
     "vue-tsc": "3.0.6"
   },

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "haex-hub"
-version = "0.1.0"
+version = "0.1.2"
 description = "A Tauri App"
 authors = ["you"]
 edition = "2021"
@@ -20,36 +20,37 @@ tauri-build = { version = "2.2", features = [] }
 serde = { version = "1.0.228", features = ["derive"] }
 
 [dependencies]
-rusqlite = { version = "0.37.0", features = [
+tokio = { version = "1.47.1", features = ["macros", "rt-multi-thread"] }
-    "load_extension",
-    "bundled-sqlcipher-vendored-openssl",
-    "functions",
-] }
-
-#tauri-plugin-sql = { version = "2", features = ["sqlite"] }tokio = { version = "1.47.1", features = ["macros", "rt-multi-thread"] }#libsqlite3-sys = { version = "0.31", features = ["bundled-sqlcipher"] }
-#sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "sqlite"] }
 base64 = "0.22"
 ed25519-dalek = "2.1"
 fs_extra = "1.3.0"
 hex = "0.4"
+lazy_static = "1.5"
 mime = "0.3"
 mime_guess = "2.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.143"
 sha2 = "0.10.9"
 sqlparser = { version = "0.59.0", features = ["visitor"] }
-tauri = { version = "2.8.5", features = ["protocol-asset", "devtools"] }
+tauri = { version = "2.9.1", features = ["protocol-asset", "devtools"] }
-tauri-plugin-dialog = "2.4.0"
+tauri-plugin-dialog = "2.4.2"
 tauri-plugin-fs = "2.4.0"
-tauri-plugin-http = "2.5.2"
+tauri-plugin-http = "2.5.4"
-tauri-plugin-notification = "2.3.1"
+tauri-plugin-notification = "2.3.3"
-tauri-plugin-opener = "2.5.0"
+tauri-plugin-opener = "2.5.2"
-tauri-plugin-os = "2.3"
+tauri-plugin-os = "2.3.2"
-tauri-plugin-persisted-scope = "2.3.2"
+tauri-plugin-persisted-scope = "2.3.4"
-tauri-plugin-store = "2.4.0"
+tauri-plugin-store = "2.4.1"
 thiserror = "2.0.17"
-ts-rs = "11.0.1"
+ts-rs = { version = "11.1.0", features = ["serde-compat"] }
-uhlc = "0.8"
+uhlc = "0.8.2"
-uuid = { version = "1.18.1", features = ["v4"] }
-zip = "5.1.1"
 url = "2.5.7"
+uuid = { version = "1.18.1", features = ["v4"] }
+zip = "6.0.0"
+
+[target.'cfg(not(target_os = "android"))'.dependencies]
+trash = "5.2.0"
+rusqlite = { version = "0.37.0", features = ["load_extension", "bundled-sqlcipher-vendored-openssl", "functions"] }
+
+[target.'cfg(target_os = "android")'.dependencies]
+rusqlite = { version = "0.37.0", features = ["load_extension", "bundled-sqlcipher-vendored-openssl", "functions"] }

src-tauri/bindings/Action.ts

@@ -0,0 +1,10 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { DbAction } from "./DbAction";
+import type { FsAction } from "./FsAction";
+import type { HttpAction } from "./HttpAction";
+import type { ShellAction } from "./ShellAction";
+
+/**
+ * Ein typsicherer Container, der die spezifische Aktion für einen Ressourcentyp enthält.
+ */
+export type Action = { "Database": DbAction } | { "Filesystem": FsAction } | { "Http": HttpAction } | { "Shell": ShellAction };

src-tauri/bindings/DatabaseError.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type DatabaseError = { "type": "ParseError", "details": { reason: string, sql: string, } } | { "type": "ParameterMismatchError", "details": { expected: number, provided: number, sql: string, } } | { "type": "NoTableError", "details": { sql: string, } } | { "type": "StatementError", "details": { reason: string, } } | { "type": "PrepareError", "details": { reason: string, } } | { "type": "DatabaseError", "details": { reason: string, } } | { "type": "ExecutionError", "details": { sql: string, reason: string, table: string | null, } } | { "type": "TransactionError", "details": { reason: string, } } | { "type": "UnsupportedStatement", "details": { reason: string, sql: string, } } | { "type": "HlcError", "details": { reason: string, } } | { "type": "LockError", "details": { reason: string, } } | { "type": "ConnectionError", "details": { reason: string, } } | { "type": "SerializationError", "details": { reason: string, } } | { "type": "PermissionError", "details": { extension_id: string, operation: string | null, resource: string | null, reason: string, } } | { "type": "QueryError", "details": { reason: string, } } | { "type": "RowProcessingError", "details": { reason: string, } } | { "type": "MutexPoisoned", "details": { reason: string, } } | { "type": "ConnectionFailed", "details": { path: string, reason: string, } } | { "type": "PragmaError", "details": { pragma: string, reason: string, } } | { "type": "PathResolutionError", "details": { reason: string, } } | { "type": "IoError", "details": { path: string, reason: string, } } | { "type": "CrdtSetup", "details": string };

src-tauri/bindings/DbAction.ts

@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Definiert Aktionen, die auf eine Datenbank angewendet werden können.
+ */
+export type DbAction = "read" | "readWrite" | "create" | "delete" | "alterDrop";

src-tauri/bindings/DbConstraints.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type DbConstraints = { where_clause: string | null, columns: Array<string> | null, limit: number | null, };

src-tauri/bindings/ExtensionInfoResponse.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ExtensionInfoResponse = { id: string, publicKey: string, name: string, version: string, author: string | null, enabled: boolean, description: string | null, homepage: string | null, icon: string | null, entry: string | null, singleInstance: boolean | null, devServerUrl: string | null, };

src-tauri/bindings/ExtensionManifest.ts

@@ -0,0 +1,4 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ExtensionPermissions } from "./ExtensionPermissions";
+
+export type ExtensionManifest = { name: string, version: string, author: string | null, entry: string | null, icon: string | null, public_key: string, signature: string, permissions: ExtensionPermissions, homepage: string | null, description: string | null, single_instance: boolean | null, };

src-tauri/bindings/ExtensionPermissions.ts

@@ -0,0 +1,7 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { PermissionEntry } from "./PermissionEntry";
+
+/**
+ * Definiert die einheitliche Struktur für alle Berechtigungsarten im Manifest und UI.
+ */
+export type ExtensionPermissions = { database: Array<PermissionEntry> | null, filesystem: Array<PermissionEntry> | null, http: Array<PermissionEntry> | null, shell: Array<PermissionEntry> | null, };

src-tauri/bindings/ExtensionPreview.ts

@@ -0,0 +1,5 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ExtensionManifest } from "./ExtensionManifest";
+import type { ExtensionPermissions } from "./ExtensionPermissions";
+
+export type ExtensionPreview = { manifest: ExtensionManifest, is_valid_signature: boolean, editable_permissions: ExtensionPermissions, };

src-tauri/bindings/FsAction.ts

@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Definiert Aktionen, die auf das Dateisystem angewendet werden können.
+ */
+export type FsAction = "read" | "readWrite";

src-tauri/bindings/FsConstraints.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type FsConstraints = { max_file_size: bigint | null, allowed_extensions: Array<string> | null, recursive: boolean | null, };

src-tauri/bindings/HttpAction.ts

@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Definiert Aktionen (HTTP-Methoden), die auf HTTP-Anfragen angewendet werden können.
+ */
+export type HttpAction = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "*";

src-tauri/bindings/HttpConstraints.ts

@@ -0,0 +1,4 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { RateLimit } from "./RateLimit";
+
+export type HttpConstraints = { methods: Array<string> | null, rate_limit: RateLimit | null, };

src-tauri/bindings/PermissionConstraints.ts

@@ -0,0 +1,7 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { DbConstraints } from "./DbConstraints";
+import type { FsConstraints } from "./FsConstraints";
+import type { HttpConstraints } from "./HttpConstraints";
+import type { ShellConstraints } from "./ShellConstraints";
+
+export type PermissionConstraints = DbConstraints | FsConstraints | HttpConstraints | ShellConstraints;

src-tauri/bindings/PermissionEntry.ts

@@ -0,0 +1,19 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { PermissionStatus } from "./PermissionStatus";
+
+/**
+ * Repräsentiert einen einzelnen Berechtigungseintrag im Manifest und im UI-Modell.
+ */
+export type PermissionEntry = { target: string, 
+/**
+ * Die auszuführende Aktion (z.B. "read", "read_write", "GET", "execute").
+ */
+operation?: string | null, 
+/**
+ * Optionale, spezifische Einschränkungen für diese Berechtigung.
+ */
+constraints?: Record<string, unknown>, 
+/**
+ * Der Status der Berechtigung (wird nur im UI-Modell verwendet).
+ */
+status?: PermissionStatus | null, };

src-tauri/bindings/PermissionStatus.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type PermissionStatus = "ask" | "granted" | "denied";

src-tauri/bindings/RateLimit.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type RateLimit = { requests: number, per_minutes: number, };

src-tauri/bindings/ResourceType.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ResourceType = "fs" | "http" | "db" | "shell";

src-tauri/bindings/ShellAction.ts

@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Definiert Aktionen, die auf Shell-Befehle angewendet werden können.
+ */
+export type ShellAction = "execute";

src-tauri/bindings/ShellConstraints.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ShellConstraints = { allowed_subcommands: Array<string> | null, allowed_flags: Array<string> | null, forbidden_args: Array<string> | null, };

src-tauri/bindings/VaultInfo.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type VaultInfo = { name: string, lastAccess: bigint, path: string, };

src-tauri/database/generate-rust-types.ts

@@ -170,6 +170,14 @@ use serde::{Deserialize, Serialize};
       table: schema.haexCrdtSnapshots,
     },
     { name: tablesNames.haex.crdt.configs.name, table: schema.haexCrdtConfigs },
+    {
+      name: tablesNames.haex.desktop_items.name,
+      table: schema.haexDesktopItems,
+    },
+    {
+      name: tablesNames.haex.workspaces.name,
+      table: schema.haexWorkspaces,
+    },
   ]
 
   for (const { name, table } of schemas) {

src-tauri/database/index.ts

@@ -19,5 +19,3 @@ const dummyExecutor = async (
 // Erstelle die Drizzle-Instanz für den SQLite-Dialekt
 // Übergib den dummyExecutor und das importierte Schema
 export const db = drizzle(dummyExecutor, { schema })
-
-// Exportiere auch alle Schema-Definitionen weiter, damit man alles aus einer Datei importieren kann

src-tauri/database/migrations/0000_dashing_night_nurse.sql

@@ -24,9 +24,23 @@ CREATE TABLE `haex_crdt_snapshots` (
 	`file_size_bytes` integer
 );
 --> statement-breakpoint
+CREATE TABLE `haex_desktop_items` (
+	`id` text PRIMARY KEY NOT NULL,
+	`workspace_id` text NOT NULL,
+	`item_type` text NOT NULL,
+	`extension_id` text,
+	`system_window_id` text,
+	`position_x` integer DEFAULT 0 NOT NULL,
+	`position_y` integer DEFAULT 0 NOT NULL,
+	`haex_timestamp` text,
+	FOREIGN KEY (`workspace_id`) REFERENCES `haex_workspaces`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`extension_id`) REFERENCES `haex_extensions`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "item_reference" CHECK(("haex_desktop_items"."item_type" = 'extension' AND "haex_desktop_items"."extension_id" IS NOT NULL AND "haex_desktop_items"."system_window_id" IS NULL) OR ("haex_desktop_items"."item_type" = 'system' AND "haex_desktop_items"."system_window_id" IS NOT NULL AND "haex_desktop_items"."extension_id" IS NULL) OR ("haex_desktop_items"."item_type" = 'file' AND "haex_desktop_items"."system_window_id" IS NOT NULL AND "haex_desktop_items"."extension_id" IS NULL) OR ("haex_desktop_items"."item_type" = 'folder' AND "haex_desktop_items"."system_window_id" IS NOT NULL AND "haex_desktop_items"."extension_id" IS NULL))
+);
+--> statement-breakpoint
 CREATE TABLE `haex_extension_permissions` (
 	`id` text PRIMARY KEY NOT NULL,
-	`extension_id` text,
+	`extension_id` text NOT NULL,
 	`resource_type` text,
 	`action` text,
 	`target` text,
@@ -34,38 +48,28 @@ CREATE TABLE `haex_extension_permissions` (
 	`status` text DEFAULT 'denied' NOT NULL,
 	`created_at` text DEFAULT (CURRENT_TIMESTAMP),
 	`updated_at` integer,
-	`haex_tombstone` integer,
 	`haex_timestamp` text,
-	FOREIGN KEY (`extension_id`) REFERENCES `haex_extensions`(`id`) ON UPDATE no action ON DELETE no action
+	FOREIGN KEY (`extension_id`) REFERENCES `haex_extensions`(`id`) ON UPDATE no action ON DELETE cascade
 );
 --> statement-breakpoint
 CREATE UNIQUE INDEX `haex_extension_permissions_extension_id_resource_type_action_target_unique` ON `haex_extension_permissions` (`extension_id`,`resource_type`,`action`,`target`);--> statement-breakpoint
 CREATE TABLE `haex_extensions` (
 	`id` text PRIMARY KEY NOT NULL,
+	`public_key` text NOT NULL,
+	`name` text NOT NULL,
+	`version` text NOT NULL,
 	`author` text,
 	`description` text,
-	`entry` text,
+	`entry` text DEFAULT 'index.html',
 	`homepage` text,
-	`enabled` integer,
+	`enabled` integer DEFAULT true,
 	`icon` text,
-	`name` text,
+	`signature` text NOT NULL,
-	`public_key` text,
+	`single_instance` integer DEFAULT false,
-	`signature` text,
-	`url` text,
-	`version` text,
-	`haex_tombstone` integer,
-	`haex_timestamp` text
-);
---> statement-breakpoint
-CREATE TABLE `haex_settings` (
-	`id` text PRIMARY KEY NOT NULL,
-	`key` text,
-	`type` text,
-	`value` text,
-	`haex_tombstone` integer,
 	`haex_timestamp` text
 );
 --> statement-breakpoint
+CREATE UNIQUE INDEX `haex_extensions_public_key_name_unique` ON `haex_extensions` (`public_key`,`name`);--> statement-breakpoint
 CREATE TABLE `haex_notifications` (
 	`id` text PRIMARY KEY NOT NULL,
 	`alt` text,
@@ -77,63 +81,24 @@ CREATE TABLE `haex_notifications` (
 	`text` text,
 	`title` text,
 	`type` text NOT NULL,
-	`haex_tombstone` integer
+	`haex_timestamp` text
 );
 --> statement-breakpoint
-CREATE TABLE `haex_passwords_group_items` (
+CREATE TABLE `haex_settings` (
-	`group_id` text,
-	`item_id` text,
-	`haex_tombstone` integer,
-	PRIMARY KEY(`item_id`, `group_id`),
-	FOREIGN KEY (`group_id`) REFERENCES `haex_passwords_groups`(`id`) ON UPDATE no action ON DELETE no action,
-	FOREIGN KEY (`item_id`) REFERENCES `haex_passwords_item_details`(`id`) ON UPDATE no action ON DELETE no action
-);
---> statement-breakpoint
-CREATE TABLE `haex_passwords_groups` (
 	`id` text PRIMARY KEY NOT NULL,
-	`name` text,
-	`description` text,
-	`icon` text,
-	`order` integer,
-	`color` text,
-	`parent_id` text,
-	`created_at` text DEFAULT (CURRENT_TIMESTAMP),
-	`updated_at` integer,
-	`haex_tombstone` integer,
-	FOREIGN KEY (`parent_id`) REFERENCES `haex_passwords_groups`(`id`) ON UPDATE no action ON DELETE no action
-);
---> statement-breakpoint
-CREATE TABLE `haex_passwords_item_details` (
-	`id` text PRIMARY KEY NOT NULL,
-	`title` text,
-	`username` text,
-	`password` text,
-	`note` text,
-	`icon` text,
-	`tags` text,
-	`url` text,
-	`created_at` text DEFAULT (CURRENT_TIMESTAMP),
-	`updated_at` integer,
-	`haex_tombstone` integer
-);
---> statement-breakpoint
-CREATE TABLE `haex_passwords_item_history` (
-	`id` text PRIMARY KEY NOT NULL,
-	`item_id` text,
-	`changed_property` text,
-	`old_value` text,
-	`new_value` text,
-	`created_at` text DEFAULT (CURRENT_TIMESTAMP),
-	`haex_tombstone` integer,
-	FOREIGN KEY (`item_id`) REFERENCES `haex_passwords_item_details`(`id`) ON UPDATE no action ON DELETE no action
-);
---> statement-breakpoint
-CREATE TABLE `haex_passwords_item_key_values` (
-	`id` text PRIMARY KEY NOT NULL,
-	`item_id` text,
 	`key` text,
+	`type` text,
 	`value` text,
-	`updated_at` integer,
+	`haex_timestamp` text
-	`haex_tombstone` integer,
-	FOREIGN KEY (`item_id`) REFERENCES `haex_passwords_item_details`(`id`) ON UPDATE no action ON DELETE no action
 );
+--> statement-breakpoint
+CREATE UNIQUE INDEX `haex_settings_key_type_value_unique` ON `haex_settings` (`key`,`type`,`value`);--> statement-breakpoint
+CREATE TABLE `haex_workspaces` (
+	`id` text PRIMARY KEY NOT NULL,
+	`device_id` text NOT NULL,
+	`name` text NOT NULL,
+	`position` integer DEFAULT 0 NOT NULL,
+	`haex_timestamp` text
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `haex_workspaces_position_unique` ON `haex_workspaces` (`position`);

src-tauri/database/migrations/0001_green_stark_industries.sql

@@ -1 +0,0 @@
-ALTER TABLE `haex_notifications` ADD `haex_timestamp` text;

src-tauri/database/migrations/meta/0000_snapshot.json

@@ -1,7 +1,7 @@
 {
   "version": "6",
   "dialect": "sqlite",
-  "id": "3bbe52b8-5933-4b21-8b24-de3927a2f9b0",
+  "id": "8dc25226-70f9-4d2e-89d4-f3a6b2bdf58d",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "tables": {
     "haex_crdt_configs": {
@@ -155,6 +155,106 @@
       "uniqueConstraints": {},
       "checkConstraints": {}
     },
+    "haex_desktop_items": {
+      "name": "haex_desktop_items",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "item_type": {
+          "name": "item_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "extension_id": {
+          "name": "extension_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "system_window_id": {
+          "name": "system_window_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "position_x": {
+          "name": "position_x",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "position_y": {
+          "name": "position_y",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "haex_timestamp": {
+          "name": "haex_timestamp",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "haex_desktop_items_workspace_id_haex_workspaces_id_fk": {
+          "name": "haex_desktop_items_workspace_id_haex_workspaces_id_fk",
+          "tableFrom": "haex_desktop_items",
+          "tableTo": "haex_workspaces",
+          "columnsFrom": [
+            "workspace_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "haex_desktop_items_extension_id_haex_extensions_id_fk": {
+          "name": "haex_desktop_items_extension_id_haex_extensions_id_fk",
+          "tableFrom": "haex_desktop_items",
+          "tableTo": "haex_extensions",
+          "columnsFrom": [
+            "extension_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "item_reference": {
+          "name": "item_reference",
+          "value": "(\"haex_desktop_items\".\"item_type\" = 'extension' AND \"haex_desktop_items\".\"extension_id\" IS NOT NULL AND \"haex_desktop_items\".\"system_window_id\" IS NULL) OR (\"haex_desktop_items\".\"item_type\" = 'system' AND \"haex_desktop_items\".\"system_window_id\" IS NOT NULL AND \"haex_desktop_items\".\"extension_id\" IS NULL) OR (\"haex_desktop_items\".\"item_type\" = 'file' AND \"haex_desktop_items\".\"system_window_id\" IS NOT NULL AND \"haex_desktop_items\".\"extension_id\" IS NULL) OR (\"haex_desktop_items\".\"item_type\" = 'folder' AND \"haex_desktop_items\".\"system_window_id\" IS NOT NULL AND \"haex_desktop_items\".\"extension_id\" IS NULL)"
+        }
+      }
+    },
     "haex_extension_permissions": {
       "name": "haex_extension_permissions",
       "columns": {
@@ -169,7 +269,7 @@
           "name": "extension_id",
           "type": "text",
           "primaryKey": false,
-          "notNull": false,
+          "notNull": true,
           "autoincrement": false
         },
         "resource_type": {
@@ -223,13 +323,6 @@
           "notNull": false,
           "autoincrement": false
         },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
         "haex_timestamp": {
           "name": "haex_timestamp",
           "type": "text",
@@ -261,7 +354,7 @@
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
+          "onDelete": "cascade",
           "onUpdate": "no action"
         }
       },
@@ -279,6 +372,27 @@
           "notNull": true,
           "autoincrement": false
         },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
         "author": {
           "name": "author",
           "type": "text",
@@ -298,7 +412,8 @@
           "type": "text",
           "primaryKey": false,
           "notNull": false,
-          "autoincrement": false
+          "autoincrement": false,
+          "default": "'index.html'"
         },
         "homepage": {
           "name": "homepage",
@@ -312,7 +427,8 @@
           "type": "integer",
           "primaryKey": false,
           "notNull": false,
-          "autoincrement": false
+          "autoincrement": false,
+          "default": true
         },
         "icon": {
           "name": "icon",
@@ -321,99 +437,20 @@
           "notNull": false,
           "autoincrement": false
         },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "public_key": {
-          "name": "public_key",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
         "signature": {
           "name": "signature",
           "type": "text",
           "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "url": {
-          "name": "url",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "version": {
-          "name": "version",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_settings": {
-      "name": "haex_settings",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
           "notNull": true,
           "autoincrement": false
         },
-        "key": {
+        "single_instance": {
-          "name": "key",
+          "name": "single_instance",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "type": {
-          "name": "type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "value": {
-          "name": "value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
           "type": "integer",
           "primaryKey": false,
           "notNull": false,
-          "autoincrement": false
+          "autoincrement": false,
+          "default": false
         },
         "haex_timestamp": {
           "name": "haex_timestamp",
@@ -423,7 +460,16 @@
           "autoincrement": false
         }
       },
-      "indexes": {},
+      "indexes": {
+        "haex_extensions_public_key_name_unique": {
+          "name": "haex_extensions_public_key_name_unique",
+          "columns": [
+            "public_key",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
       "foreignKeys": {},
       "compositePrimaryKeys": {},
       "uniqueConstraints": {},
@@ -502,9 +548,9 @@
           "notNull": true,
           "autoincrement": false
         },
-        "haex_tombstone": {
+        "haex_timestamp": {
-          "name": "haex_tombstone",
+          "name": "haex_timestamp",
-          "type": "integer",
+          "type": "text",
           "primaryKey": false,
           "notNull": false,
           "autoincrement": false
@@ -516,74 +562,8 @@
       "uniqueConstraints": {},
       "checkConstraints": {}
     },
-    "haex_passwords_group_items": {
+    "haex_settings": {
-      "name": "haex_passwords_group_items",
+      "name": "haex_settings",
-      "columns": {
-        "group_id": {
-          "name": "group_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_group_items_group_id_haex_passwords_groups_id_fk": {
-          "name": "haex_passwords_group_items_group_id_haex_passwords_groups_id_fk",
-          "tableFrom": "haex_passwords_group_items",
-          "tableTo": "haex_passwords_groups",
-          "columnsFrom": [
-            "group_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "haex_passwords_group_items_item_id_haex_passwords_item_details_id_fk": {
-          "name": "haex_passwords_group_items_item_id_haex_passwords_item_details_id_fk",
-          "tableFrom": "haex_passwords_group_items",
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "haex_passwords_group_items_item_id_group_id_pk": {
-          "columns": [
-            "item_id",
-            "group_id"
-          ],
-          "name": "haex_passwords_group_items_item_id_group_id_pk"
-        }
-      },
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_groups": {
-      "name": "haex_passwords_groups",
       "columns": {
         "id": {
           "name": "id",
@@ -592,270 +572,6 @@
           "notNull": true,
           "autoincrement": false
         },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "description": {
-          "name": "description",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "order": {
-          "name": "order",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "color": {
-          "name": "color",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "parent_id": {
-          "name": "parent_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_groups_parent_id_haex_passwords_groups_id_fk": {
-          "name": "haex_passwords_groups_parent_id_haex_passwords_groups_id_fk",
-          "tableFrom": "haex_passwords_groups",
-          "tableTo": "haex_passwords_groups",
-          "columnsFrom": [
-            "parent_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_details": {
-      "name": "haex_passwords_item_details",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "username": {
-          "name": "username",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "password": {
-          "name": "password",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "note": {
-          "name": "note",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "tags": {
-          "name": "tags",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "url": {
-          "name": "url",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_history": {
-      "name": "haex_passwords_item_history",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "changed_property": {
-          "name": "changed_property",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "old_value": {
-          "name": "old_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "new_value": {
-          "name": "new_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_item_history_item_id_haex_passwords_item_details_id_fk": {
-          "name": "haex_passwords_item_history_item_id_haex_passwords_item_details_id_fk",
-          "tableFrom": "haex_passwords_item_history",
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_key_values": {
-      "name": "haex_passwords_item_key_values",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
         "key": {
           "name": "key",
           "type": "text",
@@ -863,6 +579,13 @@
           "notNull": false,
           "autoincrement": false
         },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
         "value": {
           "name": "value",
           "type": "text",
@@ -870,37 +593,80 @@
           "notNull": false,
           "autoincrement": false
         },
-        "updated_at": {
+        "haex_timestamp": {
-          "name": "updated_at",
+          "name": "haex_timestamp",
-          "type": "integer",
+          "type": "text",
           "primaryKey": false,
           "notNull": false,
           "autoincrement": false
+        }
+      },
+      "indexes": {
+        "haex_settings_key_type_value_unique": {
+          "name": "haex_settings_key_type_value_unique",
+          "columns": [
+            "key",
+            "type",
+            "value"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "haex_workspaces": {
+      "name": "haex_workspaces",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
         },
-        "haex_tombstone": {
+        "device_id": {
-          "name": "haex_tombstone",
+          "name": "device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
           "type": "integer",
           "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "haex_timestamp": {
+          "name": "haex_timestamp",
+          "type": "text",
+          "primaryKey": false,
           "notNull": false,
           "autoincrement": false
         }
       },
-      "indexes": {},
+      "indexes": {
-      "foreignKeys": {
+        "haex_workspaces_position_unique": {
-        "haex_passwords_item_key_values_item_id_haex_passwords_item_details_id_fk": {
+          "name": "haex_workspaces_position_unique",
-          "name": "haex_passwords_item_key_values_item_id_haex_passwords_item_details_id_fk",
+          "columns": [
-          "tableFrom": "haex_passwords_item_key_values",
+            "position"
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
           ],
-          "columnsTo": [
+          "isUnique": true
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
         }
       },
+      "foreignKeys": {},
       "compositePrimaryKeys": {},
       "uniqueConstraints": {},
       "checkConstraints": {}

src-tauri/database/migrations/meta/0001_snapshot.json

@@ -1,926 +0,0 @@
-{
-  "version": "6",
-  "dialect": "sqlite",
-  "id": "862ac1d5-3065-4244-8652-2b6782254862",
-  "prevId": "3bbe52b8-5933-4b21-8b24-de3927a2f9b0",
-  "tables": {
-    "haex_crdt_configs": {
-      "name": "haex_crdt_configs",
-      "columns": {
-        "key": {
-          "name": "key",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "value": {
-          "name": "value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_crdt_logs": {
-      "name": "haex_crdt_logs",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "table_name": {
-          "name": "table_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "row_pks": {
-          "name": "row_pks",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "op_type": {
-          "name": "op_type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "column_name": {
-          "name": "column_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "new_value": {
-          "name": "new_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "old_value": {
-          "name": "old_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "idx_haex_timestamp": {
-          "name": "idx_haex_timestamp",
-          "columns": [
-            "haex_timestamp"
-          ],
-          "isUnique": false
-        },
-        "idx_table_row": {
-          "name": "idx_table_row",
-          "columns": [
-            "table_name",
-            "row_pks"
-          ],
-          "isUnique": false
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_crdt_snapshots": {
-      "name": "haex_crdt_snapshots",
-      "columns": {
-        "snapshot_id": {
-          "name": "snapshot_id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "created": {
-          "name": "created",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "epoch_hlc": {
-          "name": "epoch_hlc",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "location_url": {
-          "name": "location_url",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "file_size_bytes": {
-          "name": "file_size_bytes",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_extension_permissions": {
-      "name": "haex_extension_permissions",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "extension_id": {
-          "name": "extension_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "resource_type": {
-          "name": "resource_type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "action": {
-          "name": "action",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "target": {
-          "name": "target",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "constraints": {
-          "name": "constraints",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "status": {
-          "name": "status",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false,
-          "default": "'denied'"
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "haex_extension_permissions_extension_id_resource_type_action_target_unique": {
-          "name": "haex_extension_permissions_extension_id_resource_type_action_target_unique",
-          "columns": [
-            "extension_id",
-            "resource_type",
-            "action",
-            "target"
-          ],
-          "isUnique": true
-        }
-      },
-      "foreignKeys": {
-        "haex_extension_permissions_extension_id_haex_extensions_id_fk": {
-          "name": "haex_extension_permissions_extension_id_haex_extensions_id_fk",
-          "tableFrom": "haex_extension_permissions",
-          "tableTo": "haex_extensions",
-          "columnsFrom": [
-            "extension_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_extensions": {
-      "name": "haex_extensions",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "author": {
-          "name": "author",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "description": {
-          "name": "description",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "entry": {
-          "name": "entry",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "homepage": {
-          "name": "homepage",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "enabled": {
-          "name": "enabled",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "public_key": {
-          "name": "public_key",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "signature": {
-          "name": "signature",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "url": {
-          "name": "url",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "version": {
-          "name": "version",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_notifications": {
-      "name": "haex_notifications",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "alt": {
-          "name": "alt",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "date": {
-          "name": "date",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "image": {
-          "name": "image",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "read": {
-          "name": "read",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "source": {
-          "name": "source",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "text": {
-          "name": "text",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "type": {
-          "name": "type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_settings": {
-      "name": "haex_settings",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "key": {
-          "name": "key",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "type": {
-          "name": "type",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "value": {
-          "name": "value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_timestamp": {
-          "name": "haex_timestamp",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_group_items": {
-      "name": "haex_passwords_group_items",
-      "columns": {
-        "group_id": {
-          "name": "group_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_group_items_group_id_haex_passwords_groups_id_fk": {
-          "name": "haex_passwords_group_items_group_id_haex_passwords_groups_id_fk",
-          "tableFrom": "haex_passwords_group_items",
-          "tableTo": "haex_passwords_groups",
-          "columnsFrom": [
-            "group_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "haex_passwords_group_items_item_id_haex_passwords_item_details_id_fk": {
-          "name": "haex_passwords_group_items_item_id_haex_passwords_item_details_id_fk",
-          "tableFrom": "haex_passwords_group_items",
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "haex_passwords_group_items_item_id_group_id_pk": {
-          "columns": [
-            "item_id",
-            "group_id"
-          ],
-          "name": "haex_passwords_group_items_item_id_group_id_pk"
-        }
-      },
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_groups": {
-      "name": "haex_passwords_groups",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "description": {
-          "name": "description",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "order": {
-          "name": "order",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "color": {
-          "name": "color",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "parent_id": {
-          "name": "parent_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_groups_parent_id_haex_passwords_groups_id_fk": {
-          "name": "haex_passwords_groups_parent_id_haex_passwords_groups_id_fk",
-          "tableFrom": "haex_passwords_groups",
-          "tableTo": "haex_passwords_groups",
-          "columnsFrom": [
-            "parent_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_details": {
-      "name": "haex_passwords_item_details",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "username": {
-          "name": "username",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "password": {
-          "name": "password",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "note": {
-          "name": "note",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "icon": {
-          "name": "icon",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "tags": {
-          "name": "tags",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "url": {
-          "name": "url",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_history": {
-      "name": "haex_passwords_item_history",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "changed_property": {
-          "name": "changed_property",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "old_value": {
-          "name": "old_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "new_value": {
-          "name": "new_value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(CURRENT_TIMESTAMP)"
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_item_history_item_id_haex_passwords_item_details_id_fk": {
-          "name": "haex_passwords_item_history_item_id_haex_passwords_item_details_id_fk",
-          "tableFrom": "haex_passwords_item_history",
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    },
-    "haex_passwords_item_key_values": {
-      "name": "haex_passwords_item_key_values",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "item_id": {
-          "name": "item_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "key": {
-          "name": "key",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "value": {
-          "name": "value",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "haex_tombstone": {
-          "name": "haex_tombstone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "haex_passwords_item_key_values_item_id_haex_passwords_item_details_id_fk": {
-          "name": "haex_passwords_item_key_values_item_id_haex_passwords_item_details_id_fk",
-          "tableFrom": "haex_passwords_item_key_values",
-          "tableTo": "haex_passwords_item_details",
-          "columnsFrom": [
-            "item_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "checkConstraints": {}
-    }
-  },
-  "views": {},
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  },
-  "internal": {
-    "indexes": {}
-  }
-}

src-tauri/database/migrations/meta/_journal.json

@@ -5,15 +5,8 @@
     {
       "idx": 0,
       "version": "6",
-      "when": 1759402321133,
+      "when": 1761821821609,
-      "tag": "0000_glamorous_hulk",
+      "tag": "0000_dashing_night_nurse",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "6",
-      "when": 1759418087677,
-      "tag": "0001_green_stark_industries",
       "breakpoints": true
     }
   ]

src-tauri/database/schemas/haex.ts

@@ -1,60 +1,78 @@
 import { sql } from 'drizzle-orm'
 import {
+  check,
   integer,
   sqliteTable,
   text,
   unique,
   type AnySQLiteColumn,
+  type SQLiteColumnBuilderBase,
 } from 'drizzle-orm/sqlite-core'
 import tableNames from '../tableNames.json'
+import { crdtColumnNames } from '.'
 
-export const haexSettings = sqliteTable(tableNames.haex.settings.name, {
+// Helper function to add common CRDT columns ( haexTimestamp)
-  id: text()
+export const withCrdtColumns = <
-    .primaryKey()
+  T extends Record<string, SQLiteColumnBuilderBase>,
-    .$defaultFn(() => crypto.randomUUID()),
+>(
-  key: text(),
+  columns: T,
-  type: text(),
+) => ({
-  value: text(),
+  ...columns,
-  haexTombstone: integer(tableNames.haex.settings.columns.haexTombstone, {
+  haexTimestamp: text(crdtColumnNames.haexTimestamp),
-    mode: 'boolean',
-  }),
-  haexTimestamp: text(tableNames.haex.settings.columns.haexTimestamp),
 })
+
+export const haexSettings = sqliteTable(
+  tableNames.haex.settings.name,
+  withCrdtColumns({
+    id: text()
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    key: text(),
+    type: text(),
+    value: text(),
+  }),
+  (table) => [unique().on(table.key, table.type, table.value)],
+)
 export type InsertHaexSettings = typeof haexSettings.$inferInsert
 export type SelectHaexSettings = typeof haexSettings.$inferSelect
 
-export const haexExtensions = sqliteTable(tableNames.haex.extensions.name, {
+export const haexExtensions = sqliteTable(
-  id: text()
+  tableNames.haex.extensions.name,
-    .primaryKey()
+  withCrdtColumns({
-    .$defaultFn(() => crypto.randomUUID()),
+    id: text()
-  author: text(),
+      .primaryKey()
-  description: text(),
+      .$defaultFn(() => crypto.randomUUID()),
-  entry: text(),
+    public_key: text().notNull(),
-  homepage: text(),
+    name: text().notNull(),
-  enabled: integer({ mode: 'boolean' }),
+    version: text().notNull(),
-  icon: text(),
+    author: text(),
-  name: text(),
+    description: text(),
-  public_key: text(),
+    entry: text().default('index.html'),
-  signature: text(),
+    homepage: text(),
-  url: text(),
+    enabled: integer({ mode: 'boolean' }).default(true),
-  version: text(),
+    icon: text(),
-  haexTombstone: integer(tableNames.haex.extensions.columns.haexTombstone, {
+    signature: text().notNull(),
-    mode: 'boolean',
+    single_instance: integer({ mode: 'boolean' }).default(false),
   }),
-  haexTimestamp: text(tableNames.haex.extensions.columns.haexTimestamp),
+  (table) => [
-})
+    // UNIQUE constraint: Pro Developer (public_key) kann nur eine Extension mit diesem Namen existieren
+    unique().on(table.public_key, table.name),
+  ],
+)
 export type InsertHaexExtensions = typeof haexExtensions.$inferInsert
 export type SelectHaexExtensions = typeof haexExtensions.$inferSelect
 
 export const haexExtensionPermissions = sqliteTable(
   tableNames.haex.extension_permissions.name,
-  {
+  withCrdtColumns({
     id: text()
       .primaryKey()
       .$defaultFn(() => crypto.randomUUID()),
-    extensionId: text(
+    extensionId: text(tableNames.haex.extension_permissions.columns.extensionId)
-      tableNames.haex.extension_permissions.columns.extensionId,
+      .notNull()
-    ).references((): AnySQLiteColumn => haexExtensions.id),
+      .references((): AnySQLiteColumn => haexExtensions.id, {
+        onDelete: 'cascade',
+      }),
     resourceType: text('resource_type', {
       enum: ['fs', 'http', 'db', 'shell'],
     }),
@@ -68,14 +86,7 @@ export const haexExtensionPermissions = sqliteTable(
     updateAt: integer('updated_at', { mode: 'timestamp' }).$onUpdate(
       () => new Date(),
     ),
-    haexTombstone: integer(
+  }),
-      tableNames.haex.extension_permissions.columns.haexTombstone,
-      { mode: 'boolean' },
-    ),
-    haexTimestamp: text(
-      tableNames.haex.extension_permissions.columns.haexTimestamp,
-    ),
-  },
   (table) => [
     unique().on(
       table.extensionId,
@@ -92,7 +103,7 @@ export type SelecthaexExtensionPermissions =
 
 export const haexNotifications = sqliteTable(
   tableNames.haex.notifications.name,
-  {
+  withCrdtColumns({
     id: text().primaryKey(),
     alt: text(),
     date: text(),
@@ -105,12 +116,61 @@ export const haexNotifications = sqliteTable(
     type: text({
       enum: ['error', 'success', 'warning', 'info', 'log'],
     }).notNull(),
-    haexTombstone: integer(
+  }),
-      tableNames.haex.notifications.columns.haexTombstone,
-      { mode: 'boolean' },
-    ),
-    haexTimestamp: text(tableNames.haex.notifications.columns.haexTimestamp),
-  },
 )
 export type InsertHaexNotifications = typeof haexNotifications.$inferInsert
 export type SelectHaexNotifications = typeof haexNotifications.$inferSelect
+
+export const haexWorkspaces = sqliteTable(
+  tableNames.haex.workspaces.name,
+  withCrdtColumns({
+    id: text(tableNames.haex.workspaces.columns.id)
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    deviceId: text(tableNames.haex.workspaces.columns.deviceId).notNull(),
+    name: text(tableNames.haex.workspaces.columns.name).notNull(),
+    position: integer(tableNames.haex.workspaces.columns.position)
+      .notNull()
+      .default(0),
+  }),
+  (table) => [unique().on(table.position)],
+)
+export type InsertHaexWorkspaces = typeof haexWorkspaces.$inferInsert
+export type SelectHaexWorkspaces = typeof haexWorkspaces.$inferSelect
+
+export const haexDesktopItems = sqliteTable(
+  tableNames.haex.desktop_items.name,
+  withCrdtColumns({
+    id: text(tableNames.haex.desktop_items.columns.id)
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    workspaceId: text(tableNames.haex.desktop_items.columns.workspaceId)
+      .notNull()
+      .references(() => haexWorkspaces.id, { onDelete: 'cascade' }),
+    itemType: text(tableNames.haex.desktop_items.columns.itemType, {
+      enum: ['system', 'extension', 'file', 'folder'],
+    }).notNull(),
+    // Für Extensions (wenn itemType = 'extension')
+    extensionId: text(
+      tableNames.haex.desktop_items.columns.extensionId,
+    ).references((): AnySQLiteColumn => haexExtensions.id, {
+      onDelete: 'cascade',
+    }),
+    // Für System Windows (wenn itemType = 'system')
+    systemWindowId: text(tableNames.haex.desktop_items.columns.systemWindowId),
+    positionX: integer(tableNames.haex.desktop_items.columns.positionX)
+      .notNull()
+      .default(0),
+    positionY: integer(tableNames.haex.desktop_items.columns.positionY)
+      .notNull()
+      .default(0),
+  }),
+  (table) => [
+    check(
+      'item_reference',
+      sql`(${table.itemType} = 'extension' AND ${table.extensionId} IS NOT NULL AND ${table.systemWindowId} IS NULL) OR (${table.itemType} = 'system' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL) OR (${table.itemType} = 'file' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL) OR (${table.itemType} = 'folder' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL)`,
+    ),
+  ],
+)
+export type InsertHaexDesktopItems = typeof haexDesktopItems.$inferInsert
+export type SelectHaexDesktopItems = typeof haexDesktopItems.$inferSelect

src-tauri/database/schemas/index.ts

@@ -1,2 +1,5 @@
+export const crdtColumnNames = {
+  haexTimestamp: 'haex_timestamp',
+}
 export * from './crdt'
 export * from './haex'

src-tauri/database/schemas/vault.ts

@@ -1,112 +0,0 @@
-import { sql } from 'drizzle-orm'
-import {
-  integer,
-  primaryKey,
-  sqliteTable,
-  text,
-  type AnySQLiteColumn,
-} from 'drizzle-orm/sqlite-core'
-import tableNames from '../tableNames.json'
-
-export const haexPasswordsItemDetails = sqliteTable(
-  tableNames.haex.passwords.item_details,
-  {
-    id: text().primaryKey(),
-    title: text(),
-    username: text(),
-    password: text(),
-    note: text(),
-    icon: text(),
-    tags: text(),
-    url: text(),
-    createdAt: text('created_at').default(sql`(CURRENT_TIMESTAMP)`),
-    updateAt: integer('updated_at', { mode: 'timestamp' }).$onUpdate(
-      () => new Date(),
-    ),
-    haex_tombstone: integer({ mode: 'boolean' }),
-  },
-)
-export type InsertHaexPasswordsItemDetails =
-  typeof haexPasswordsItemDetails.$inferInsert
-export type SelectHaexPasswordsItemDetails =
-  typeof haexPasswordsItemDetails.$inferSelect
-
-export const haexPasswordsItemKeyValues = sqliteTable(
-  tableNames.haex.passwords.item_key_values,
-  {
-    id: text().primaryKey(),
-    itemId: text('item_id').references(
-      (): AnySQLiteColumn => haexPasswordsItemDetails.id,
-    ),
-    key: text(),
-    value: text(),
-    updateAt: integer('updated_at', { mode: 'timestamp' }).$onUpdate(
-      () => new Date(),
-    ),
-    haex_tombstone: integer({ mode: 'boolean' }),
-  },
-)
-export type InserthaexPasswordsItemKeyValues =
-  typeof haexPasswordsItemKeyValues.$inferInsert
-export type SelectHaexPasswordsItemKeyValues =
-  typeof haexPasswordsItemKeyValues.$inferSelect
-
-export const haexPasswordsItemHistory = sqliteTable(
-  tableNames.haex.passwords.item_histories,
-  {
-    id: text().primaryKey(),
-    itemId: text('item_id').references(
-      (): AnySQLiteColumn => haexPasswordsItemDetails.id,
-    ),
-    changedProperty:
-      text('changed_property').$type<keyof typeof haexPasswordsItemDetails>(),
-    oldValue: text('old_value'),
-    newValue: text('new_value'),
-    createdAt: text('created_at').default(sql`(CURRENT_TIMESTAMP)`),
-    haex_tombstone: integer({ mode: 'boolean' }),
-  },
-)
-export type InserthaexPasswordsItemHistory =
-  typeof haexPasswordsItemHistory.$inferInsert
-export type SelectHaexPasswordsItemHistory =
-  typeof haexPasswordsItemHistory.$inferSelect
-
-export const haexPasswordsGroups = sqliteTable(
-  tableNames.haex.passwords.groups,
-  {
-    id: text().primaryKey(),
-    name: text(),
-    description: text(),
-    icon: text(),
-    order: integer(),
-    color: text(),
-    parentId: text('parent_id').references(
-      (): AnySQLiteColumn => haexPasswordsGroups.id,
-    ),
-    createdAt: text('created_at').default(sql`(CURRENT_TIMESTAMP)`),
-    updateAt: integer('updated_at', { mode: 'timestamp' }).$onUpdate(
-      () => new Date(),
-    ),
-    haex_tombstone: integer({ mode: 'boolean' }),
-  },
-)
-export type InsertHaexPasswordsGroups = typeof haexPasswordsGroups.$inferInsert
-export type SelectHaexPasswordsGroups = typeof haexPasswordsGroups.$inferSelect
-
-export const haexPasswordsGroupItems = sqliteTable(
-  tableNames.haex.passwords.group_items,
-  {
-    groupId: text('group_id').references(
-      (): AnySQLiteColumn => haexPasswordsGroups.id,
-    ),
-    itemId: text('item_id').references(
-      (): AnySQLiteColumn => haexPasswordsItemDetails.id,
-    ),
-    haex_tombstone: integer({ mode: 'boolean' }),
-  },
-  (table) => [primaryKey({ columns: [table.itemId, table.groupId] })],
-)
-export type InsertHaexPasswordsGroupItems =
-  typeof haexPasswordsGroupItems.$inferInsert
-export type SelectHaexPasswordsGroupItems =
-  typeof haexPasswordsGroupItems.$inferSelect

src-tauri/database/tableNames.json

@@ -7,7 +7,7 @@
         "key": "key",
         "type": "type",
         "value": "value",
-        "haexTombstone": "haex_tombstone",
+
         "haexTimestamp": "haex_timestamp"
       }
     },
@@ -26,7 +26,7 @@
         "signature": "signature",
         "url": "url",
         "version": "version",
-        "haexTombstone": "haex_tombstone",
+
         "haexTimestamp": "haex_timestamp"
       }
     },
@@ -42,7 +42,7 @@
         "status": "status",
         "createdAt": "created_at",
         "updateAt": "updated_at",
-        "haexTombstone": "haex_tombstone",
+
         "haexTimestamp": "haex_timestamp"
       }
     },
@@ -59,17 +59,37 @@
         "text": "text",
         "title": "title",
         "type": "type",
-        "haexTombstone": "haex_tombstone",
+
         "haexTimestamp": "haex_timestamp"
       }
     },
-    "passwords": {
+    "workspaces": {
-      "groups": "haex_passwords_groups",
+      "name": "haex_workspaces",
-      "group_items": "haex_passwords_group_items",
+      "columns": {
-      "item_details": "haex_passwords_item_details",
+        "id": "id",
-      "item_key_values": "haex_passwords_item_key_values",
+        "deviceId": "device_id",
-      "item_histories": "haex_passwords_item_history"
+        "name": "name",
+        "position": "position",
+        "createdAt": "created_at",
+
+        "haexTimestamp": "haex_timestamp"
+      }
     },
+    "desktop_items": {
+      "name": "haex_desktop_items",
+      "columns": {
+        "id": "id",
+        "workspaceId": "workspace_id",
+        "itemType": "item_type",
+        "extensionId": "extension_id",
+        "systemWindowId": "system_window_id",
+        "positionX": "position_x",
+        "positionY": "position_y",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+
     "crdt": {
       "logs": {
         "name": "haex_crdt_logs",

src-tauri/gen/android/app/build.gradle.kts

@@ -24,6 +24,23 @@ android {
         versionCode = tauriProperties.getProperty("tauri.android.versionCode", "1").toInt()
         versionName = tauriProperties.getProperty("tauri.android.versionName", "1.0")
     }
+
+    signingConfigs {
+        create("release") {
+            val keystorePath = System.getenv("ANDROID_KEYSTORE_PATH")
+            val keystorePassword = System.getenv("ANDROID_KEYSTORE_PASSWORD")
+            val keyAlias = System.getenv("ANDROID_KEY_ALIAS")
+            val keyPassword = System.getenv("ANDROID_KEY_PASSWORD")
+
+            if (keystorePath != null && keystorePassword != null && keyAlias != null && keyPassword != null) {
+                storeFile = file(keystorePath)
+                storePassword = keystorePassword
+                this.keyAlias = keyAlias
+                this.keyPassword = keyPassword
+            }
+        }
+    }
+
     buildTypes {
         getByName("debug") {
             manifestPlaceholders["usesCleartextTraffic"] = "true"
@@ -43,6 +60,12 @@ android {
                     .plus(getDefaultProguardFile("proguard-android-optimize.txt"))
                     .toList().toTypedArray()
             )
+
+            // Sign with release config if available
+            val releaseSigningConfig = signingConfigs.getByName("release")
+            if (releaseSigningConfig.storeFile != null) {
+                signingConfig = releaseSigningConfig
+            }
         }
     }
     kotlinOptions {

src-tauri/gen/schemas/android-schema.json

@@ -1400,10 +1400,10 @@
                         "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
                       },
                       {
-                        "description": "An empty permission you can use to modify the global scope.",
+                        "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
                         "type": "string",
                         "const": "fs:scope",
-                        "markdownDescription": "An empty permission you can use to modify the global scope."
+                        "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
                       },
                       {
                         "description": "This scope permits access to all files and list content of top level directories in the application folders.",
@@ -2270,12 +2270,6 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
-        {
-          "description": "Default permissions for the plugin",
-          "type": "string",
-          "const": "android-fs:default",
-          "markdownDescription": "Default permissions for the plugin"
-        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",
@@ -2283,10 +2277,10 @@
           "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
         },
         {
-          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`",
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`",
           "type": "string",
           "const": "core:app:default",
-          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`"
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`"
         },
         {
           "description": "Enables the app_hide command without any pre-configured scope.",
@@ -2330,12 +2324,24 @@
           "const": "core:app:allow-name",
           "markdownDescription": "Enables the name command without any pre-configured scope."
         },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:allow-remove-data-store",
           "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Enables the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-listener",
+          "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -2402,12 +2408,24 @@
           "const": "core:app:deny-name",
           "markdownDescription": "Denies the name command without any pre-configured scope."
         },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:deny-remove-data-store",
           "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Denies the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-listener",
+          "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -5547,10 +5565,10 @@
           "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
         },
         {
-          "description": "An empty permission you can use to modify the global scope.",
+          "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
           "type": "string",
           "const": "fs:scope",
-          "markdownDescription": "An empty permission you can use to modify the global scope."
+          "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
         },
         {
           "description": "This scope permits access to all files and list content of top level directories in the application folders.",

src-tauri/gen/schemas/desktop-schema.json

@@ -1400,10 +1400,10 @@
                         "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
                       },
                       {
-                        "description": "An empty permission you can use to modify the global scope.",
+                        "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
                         "type": "string",
                         "const": "fs:scope",
-                        "markdownDescription": "An empty permission you can use to modify the global scope."
+                        "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
                       },
                       {
                         "description": "This scope permits access to all files and list content of top level directories in the application folders.",
@@ -2277,10 +2277,10 @@
           "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
         },
         {
-          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`",
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`",
           "type": "string",
           "const": "core:app:default",
-          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`"
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`"
         },
         {
           "description": "Enables the app_hide command without any pre-configured scope.",
@@ -2324,12 +2324,24 @@
           "const": "core:app:allow-name",
           "markdownDescription": "Enables the name command without any pre-configured scope."
         },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:allow-remove-data-store",
           "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Enables the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-listener",
+          "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -2396,12 +2408,24 @@
           "const": "core:app:deny-name",
           "markdownDescription": "Denies the name command without any pre-configured scope."
         },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:deny-remove-data-store",
           "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Denies the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-listener",
+          "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -5541,10 +5565,10 @@
           "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
         },
         {
-          "description": "An empty permission you can use to modify the global scope.",
+          "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
           "type": "string",
           "const": "fs:scope",
-          "markdownDescription": "An empty permission you can use to modify the global scope."
+          "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
         },
         {
           "description": "This scope permits access to all files and list content of top level directories in the application folders.",

src-tauri/gen/schemas/linux-schema.json

@@ -1400,10 +1400,10 @@
                         "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
                       },
                       {
-                        "description": "An empty permission you can use to modify the global scope.",
+                        "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
                         "type": "string",
                         "const": "fs:scope",
-                        "markdownDescription": "An empty permission you can use to modify the global scope."
+                        "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
                       },
                       {
                         "description": "This scope permits access to all files and list content of top level directories in the application folders.",
@@ -2277,10 +2277,10 @@
           "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
         },
         {
-          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`",
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`",
           "type": "string",
           "const": "core:app:default",
-          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`"
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`"
         },
         {
           "description": "Enables the app_hide command without any pre-configured scope.",
@@ -2324,12 +2324,24 @@
           "const": "core:app:allow-name",
           "markdownDescription": "Enables the name command without any pre-configured scope."
         },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:allow-remove-data-store",
           "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Enables the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-listener",
+          "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -2396,12 +2408,24 @@
           "const": "core:app:deny-name",
           "markdownDescription": "Denies the name command without any pre-configured scope."
         },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:deny-remove-data-store",
           "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Denies the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-listener",
+          "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -5541,10 +5565,10 @@
           "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
         },
         {
-          "description": "An empty permission you can use to modify the global scope.",
+          "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
           "type": "string",
           "const": "fs:scope",
-          "markdownDescription": "An empty permission you can use to modify the global scope."
+          "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
         },
         {
           "description": "This scope permits access to all files and list content of top level directories in the application folders.",

src-tauri/gen/schemas/mobile-schema.json

@@ -1400,10 +1400,10 @@
                         "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
                       },
                       {
-                        "description": "An empty permission you can use to modify the global scope.",
+                        "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
                         "type": "string",
                         "const": "fs:scope",
-                        "markdownDescription": "An empty permission you can use to modify the global scope."
+                        "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
                       },
                       {
                         "description": "This scope permits access to all files and list content of top level directories in the application folders.",
@@ -2270,12 +2270,6 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
-        {
-          "description": "Default permissions for the plugin",
-          "type": "string",
-          "const": "android-fs:default",
-          "markdownDescription": "Default permissions for the plugin"
-        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",
@@ -2283,10 +2277,10 @@
           "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
         },
         {
-          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`",
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`",
           "type": "string",
           "const": "core:app:default",
-          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`"
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`"
         },
         {
           "description": "Enables the app_hide command without any pre-configured scope.",
@@ -2330,12 +2324,24 @@
           "const": "core:app:allow-name",
           "markdownDescription": "Enables the name command without any pre-configured scope."
         },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:allow-remove-data-store",
           "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Enables the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-listener",
+          "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -2402,12 +2408,24 @@
           "const": "core:app:deny-name",
           "markdownDescription": "Denies the name command without any pre-configured scope."
         },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the remove_data_store command without any pre-configured scope.",
           "type": "string",
           "const": "core:app:deny-remove-data-store",
           "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
         },
+        {
+          "description": "Denies the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-listener",
+          "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_app_theme command without any pre-configured scope.",
           "type": "string",
@@ -5547,10 +5565,10 @@
           "markdownDescription": "This enables all index or metadata related commands without any pre-configured accessible paths."
         },
         {
-          "description": "An empty permission you can use to modify the global scope.",
+          "description": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n",
           "type": "string",
           "const": "fs:scope",
-          "markdownDescription": "An empty permission you can use to modify the global scope."
+          "markdownDescription": "An empty permission you can use to modify the global scope.\n\n## Example\n\n```json\n{\n  \"identifier\": \"read-documents\",\n  \"windows\": [\"main\"],\n  \"permissions\": [\n    \"fs:allow-read\",\n    {\n      \"identifier\": \"fs:scope\",\n      \"allow\": [\n        \"$APPDATA/documents/**/*\"\n      ],\n      \"deny\": [\n        \"$APPDATA/documents/secret.txt\"\n      ]\n    }\n  ]\n}\n```\n"
         },
         {
           "description": "This scope permits access to all files and list content of top level directories in the application folders.",

src-tauri/generator/table_names.rs

@@ -1,5 +1,6 @@
 // src-tarui/src/build/table_names.rs
 use serde::Deserialize;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::env;
 use std::fs::File;
@@ -8,24 +9,7 @@ use std::path::Path;
 
 #[derive(Debug, Deserialize)]
 struct Schema {
-    haex: Haex,
+    haex: HashMap<String, Value>,
-}
-
-#[derive(Debug, Deserialize)]
-#[allow(non_snake_case)]
-struct Haex {
-    settings: TableDefinition,
-    extensions: TableDefinition,
-    extension_permissions: TableDefinition,
-    notifications: TableDefinition,
-    crdt: Crdt,
-}
-
-#[derive(Debug, Deserialize)]
-struct Crdt {
-    logs: TableDefinition,
-    snapshots: TableDefinition,
-    configs: TableDefinition,
 }
 
 #[derive(Debug, Deserialize)]
@@ -44,166 +28,39 @@ pub fn generate_table_names() {
     let reader = BufReader::new(file);
     let schema: Schema =
         serde_json::from_reader(reader).expect("Konnte tableNames.json nicht parsen");
-    let haex = schema.haex;
 
-    let code = format!(
+    let mut code = String::from(
         r#"
 // ==================================================================
 // HINWEIS: Diese Datei wurde automatisch von build.rs generiert.
 // Manuelle Änderungen werden bei der nächsten Kompilierung überschrieben!
 // ==================================================================
 
-// --- Table: haex_settings ---
-pub const TABLE_SETTINGS: &str = "{t_settings}";
-pub const COL_SETTINGS_ID: &str = "{c_settings_id}";
-pub const COL_SETTINGS_KEY: &str = "{c_settings_key}";
-pub const COL_SETTINGS_TYPE: &str = "{c_settings_type}";
-pub const COL_SETTINGS_VALUE: &str = "{c_settings_value}";
-pub const COL_SETTINGS_HAEX_TOMBSTONE: &str = "{c_settings_tombstone}";
-pub const COL_SETTINGS_HAEX_TIMESTAMP: &str = "{c_settings_timestamp}";
-
-// --- Table: haex_extensions ---
-pub const TABLE_EXTENSIONS: &str = "{t_extensions}";
-pub const COL_EXTENSIONS_ID: &str = "{c_ext_id}";
-pub const COL_EXTENSIONS_AUTHOR: &str = "{c_ext_author}";
-pub const COL_EXTENSIONS_DESCRIPTION: &str = "{c_ext_description}";
-pub const COL_EXTENSIONS_ENTRY: &str = "{c_ext_entry}";
-pub const COL_EXTENSIONS_HOMEPAGE: &str = "{c_ext_homepage}";
-pub const COL_EXTENSIONS_ENABLED: &str = "{c_ext_enabled}";
-pub const COL_EXTENSIONS_ICON: &str = "{c_ext_icon}";
-pub const COL_EXTENSIONS_NAME: &str = "{c_ext_name}";
-pub const COL_EXTENSIONS_PUBLIC_KEY: &str = "{c_ext_public_key}";
-pub const COL_EXTENSIONS_SIGNATURE: &str = "{c_ext_signature}";
-pub const COL_EXTENSIONS_URL: &str = "{c_ext_url}";
-pub const COL_EXTENSIONS_VERSION: &str = "{c_ext_version}";
-pub const COL_EXTENSIONS_HAEX_TOMBSTONE: &str = "{c_ext_tombstone}";
-pub const COL_EXTENSIONS_HAEX_TIMESTAMP: &str = "{c_ext_timestamp}";
-
-// --- Table: haex_extension_permissions ---
-pub const TABLE_EXTENSION_PERMISSIONS: &str = "{t_ext_perms}";
-pub const COL_EXT_PERMS_ID: &str = "{c_extp_id}";
-pub const COL_EXT_PERMS_EXTENSION_ID: &str = "{c_extp_extensionId}";
-pub const COL_EXT_PERMS_RESOURCE_TYPE: &str = "{c_extp_resourceType}";
-pub const COL_EXT_PERMS_ACTION: &str = "{c_extp_action}";
-pub const COL_EXT_PERMS_TARGET: &str = "{c_extp_target}";
-pub const COL_EXT_PERMS_CONSTRAINTS: &str = "{c_extp_constraints}";
-pub const COL_EXT_PERMS_STATUS: &str = "{c_extp_status}";
-pub const COL_EXT_PERMS_CREATED_AT: &str = "{c_extp_createdAt}";
-pub const COL_EXT_PERMS_UPDATE_AT: &str = "{c_extp_updateAt}";
-pub const COL_EXT_PERMS_HAEX_TOMBSTONE: &str = "{c_extp_tombstone}";
-pub const COL_EXT_PERMS_HAEX_TIMESTAMP: &str = "{c_extp_timestamp}";
-
-// --- Table: haex_notifications ---
-pub const TABLE_NOTIFICATIONS: &str = "{t_notifications}";
-pub const COL_NOTIFICATIONS_ID: &str = "{c_notif_id}";
-pub const COL_NOTIFICATIONS_ALT: &str = "{c_notif_alt}";
-pub const COL_NOTIFICATIONS_DATE: &str = "{c_notif_date}";
-pub const COL_NOTIFICATIONS_ICON: &str = "{c_notif_icon}";
-pub const COL_NOTIFICATIONS_IMAGE: &str = "{c_notif_image}";
-pub const COL_NOTIFICATIONS_READ: &str = "{c_notif_read}";
-pub const COL_NOTIFICATIONS_SOURCE: &str = "{c_notif_source}";
-pub const COL_NOTIFICATIONS_TEXT: &str = "{c_notif_text}";
-pub const COL_NOTIFICATIONS_TITLE: &str = "{c_notif_title}";
-pub const COL_NOTIFICATIONS_TYPE: &str = "{c_notif_type}";
-pub const COL_NOTIFICATIONS_HAEX_TOMBSTONE: &str = "{c_notif_tombstone}";
-
-// --- Table: haex_crdt_logs ---
-pub const TABLE_CRDT_LOGS: &str = "{t_crdt_logs}";
-pub const COL_CRDT_LOGS_ID: &str = "{c_crdt_logs_id}";
-pub const COL_CRDT_LOGS_HAEX_TIMESTAMP: &str = "{c_crdt_logs_timestamp}";
-pub const COL_CRDT_LOGS_TABLE_NAME: &str = "{c_crdt_logs_tableName}";
-pub const COL_CRDT_LOGS_ROW_PKS: &str = "{c_crdt_logs_rowPks}";
-pub const COL_CRDT_LOGS_OP_TYPE: &str = "{c_crdt_logs_opType}";
-pub const COL_CRDT_LOGS_COLUMN_NAME: &str = "{c_crdt_logs_columnName}";
-pub const COL_CRDT_LOGS_NEW_VALUE: &str = "{c_crdt_logs_newValue}";
-pub const COL_CRDT_LOGS_OLD_VALUE: &str = "{c_crdt_logs_oldValue}";
-
-// --- Table: haex_crdt_snapshots ---
-pub const TABLE_CRDT_SNAPSHOTS: &str = "{t_crdt_snapshots}";
-pub const COL_CRDT_SNAPSHOTS_ID: &str = "{c_crdt_snap_id}";
-pub const COL_CRDT_SNAPSHOTS_CREATED: &str = "{c_crdt_snap_created}";
-pub const COL_CRDT_SNAPSHOTS_EPOCH_HLC: &str = "{c_crdt_snap_epoch}";
-pub const COL_CRDT_SNAPSHOTS_LOCATION_URL: &str = "{c_crdt_snap_location}";
-pub const COL_CRDT_SNAPSHOTS_FILE_SIZE: &str = "{c_crdt_snap_size}";
-
-// --- Table: haex_crdt_configs ---
-pub const TABLE_CRDT_CONFIGS: &str = "{t_crdt_configs}";
-pub const COL_CRDT_CONFIGS_KEY: &str = "{c_crdt_configs_key}";
-pub const COL_CRDT_CONFIGS_VALUE: &str = "{c_crdt_configs_value}";
 "#,
-        // Settings
-        t_settings = haex.settings.name,
-        c_settings_id = haex.settings.columns["id"],
-        c_settings_key = haex.settings.columns["key"],
-        c_settings_type = haex.settings.columns["type"],
-        c_settings_value = haex.settings.columns["value"],
-        c_settings_tombstone = haex.settings.columns["haexTombstone"],
-        c_settings_timestamp = haex.settings.columns["haexTimestamp"],
-        // Extensions
-        t_extensions = haex.extensions.name,
-        c_ext_id = haex.extensions.columns["id"],
-        c_ext_author = haex.extensions.columns["author"],
-        c_ext_description = haex.extensions.columns["description"],
-        c_ext_entry = haex.extensions.columns["entry"],
-        c_ext_homepage = haex.extensions.columns["homepage"],
-        c_ext_enabled = haex.extensions.columns["enabled"],
-        c_ext_icon = haex.extensions.columns["icon"],
-        c_ext_name = haex.extensions.columns["name"],
-        c_ext_public_key = haex.extensions.columns["public_key"],
-        c_ext_signature = haex.extensions.columns["signature"],
-        c_ext_url = haex.extensions.columns["url"],
-        c_ext_version = haex.extensions.columns["version"],
-        c_ext_tombstone = haex.extensions.columns["haexTombstone"],
-        c_ext_timestamp = haex.extensions.columns["haexTimestamp"],
-        // Extension Permissions
-        t_ext_perms = haex.extension_permissions.name,
-        c_extp_id = haex.extension_permissions.columns["id"],
-        c_extp_extensionId = haex.extension_permissions.columns["extensionId"],
-        c_extp_resourceType = haex.extension_permissions.columns["resourceType"],
-        c_extp_action = haex.extension_permissions.columns["action"],
-        c_extp_target = haex.extension_permissions.columns["target"],
-        c_extp_constraints = haex.extension_permissions.columns["constraints"],
-        c_extp_status = haex.extension_permissions.columns["status"],
-        c_extp_createdAt = haex.extension_permissions.columns["createdAt"],
-        c_extp_updateAt = haex.extension_permissions.columns["updateAt"],
-        c_extp_tombstone = haex.extension_permissions.columns["haexTombstone"],
-        c_extp_timestamp = haex.extension_permissions.columns["haexTimestamp"],
-        // Notifications
-        t_notifications = haex.notifications.name,
-        c_notif_id = haex.notifications.columns["id"],
-        c_notif_alt = haex.notifications.columns["alt"],
-        c_notif_date = haex.notifications.columns["date"],
-        c_notif_icon = haex.notifications.columns["icon"],
-        c_notif_image = haex.notifications.columns["image"],
-        c_notif_read = haex.notifications.columns["read"],
-        c_notif_source = haex.notifications.columns["source"],
-        c_notif_text = haex.notifications.columns["text"],
-        c_notif_title = haex.notifications.columns["title"],
-        c_notif_type = haex.notifications.columns["type"],
-        c_notif_tombstone = haex.notifications.columns["haexTombstone"],
-        // CRDT Logs
-        t_crdt_logs = haex.crdt.logs.name,
-        c_crdt_logs_id = haex.crdt.logs.columns["id"],
-        c_crdt_logs_timestamp = haex.crdt.logs.columns["haexTimestamp"],
-        c_crdt_logs_tableName = haex.crdt.logs.columns["tableName"],
-        c_crdt_logs_rowPks = haex.crdt.logs.columns["rowPks"],
-        c_crdt_logs_opType = haex.crdt.logs.columns["opType"],
-        c_crdt_logs_columnName = haex.crdt.logs.columns["columnName"],
-        c_crdt_logs_newValue = haex.crdt.logs.columns["newValue"],
-        c_crdt_logs_oldValue = haex.crdt.logs.columns["oldValue"],
-        // CRDT Snapshots
-        t_crdt_snapshots = haex.crdt.snapshots.name,
-        c_crdt_snap_id = haex.crdt.snapshots.columns["snapshotId"],
-        c_crdt_snap_created = haex.crdt.snapshots.columns["created"],
-        c_crdt_snap_epoch = haex.crdt.snapshots.columns["epochHlc"],
-        c_crdt_snap_location = haex.crdt.snapshots.columns["locationUrl"],
-        c_crdt_snap_size = haex.crdt.snapshots.columns["fileSizeBytes"],
-        // CRDT Configs
-        t_crdt_configs = haex.crdt.configs.name,
-        c_crdt_configs_key = haex.crdt.configs.columns["key"],
-        c_crdt_configs_value = haex.crdt.configs.columns["value"]
     );
 
+    // Dynamisch über alle Einträge in haex iterieren
+    for (key, value) in &schema.haex {
+        // Spezialbehandlung für nested structures wie "crdt"
+        if key == "crdt" {
+            if let Some(crdt_obj) = value.as_object() {
+                for (crdt_key, crdt_value) in crdt_obj {
+                    if let Ok(table) = serde_json::from_value::<TableDefinition>(crdt_value.clone())
+                    {
+                        let const_prefix = format!("CRDT_{}", to_screaming_snake_case(crdt_key));
+                        code.push_str(&generate_table_constants(&table, &const_prefix));
+                    }
+                }
+            }
+        } else {
+            // Normale Tabelle (settings, extensions, notifications, workspaces, desktop_items, etc.)
+            if let Ok(table) = serde_json::from_value::<TableDefinition>(value.clone()) {
+                let const_prefix = to_screaming_snake_case(key);
+                code.push_str(&generate_table_constants(&table, &const_prefix));
+            }
+        }
+    }
+
     // --- Datei schreiben ---
     let mut f = File::create(&dest_path).expect("Konnte Zieldatei nicht erstellen");
     f.write_all(code.as_bytes())
@@ -211,3 +68,51 @@ pub const COL_CRDT_CONFIGS_VALUE: &str = "{c_crdt_configs_value}";
 
     println!("cargo:rerun-if-changed=database/tableNames.json");
 }
+
+/// Konvertiert einen String zu SCREAMING_SNAKE_CASE
+fn to_screaming_snake_case(s: &str) -> String {
+    let mut result = String::new();
+    let mut prev_is_lower = false;
+
+    for (i, ch) in s.chars().enumerate() {
+        if ch == '_' {
+            result.push('_');
+            prev_is_lower = false;
+        } else if ch.is_uppercase() {
+            if i > 0 && prev_is_lower {
+                result.push('_');
+            }
+            result.push(ch);
+            prev_is_lower = false;
+        } else {
+            result.push(ch.to_ascii_uppercase());
+            prev_is_lower = true;
+        }
+    }
+
+    result
+}
+
+/// Generiert die Konstanten für eine Tabelle
+fn generate_table_constants(table: &TableDefinition, const_prefix: &str) -> String {
+    let mut code = String::new();
+
+    // Tabellenname
+    code.push_str(&format!("// --- Table: {} ---\n", table.name));
+    code.push_str(&format!(
+        "pub const TABLE_{}: &str = \"{}\";\n",
+        const_prefix, table.name
+    ));
+
+    // Spalten
+    for (col_key, col_value) in &table.columns {
+        let col_const_name = format!("COL_{}_{}", const_prefix, to_screaming_snake_case(col_key));
+        code.push_str(&format!(
+            "pub const {}: &str = \"{}\";\n",
+            col_const_name, col_value
+        ));
+    }
+
+    code.push('\n');
+    code
+}

src-tauri/src/crdt/insert_transformer.rs

@@ -0,0 +1,99 @@
+// src-tauri/src/crdt/insert_transformer.rs
+// INSERT-spezifische CRDT-Transformationen (ON CONFLICT, RETURNING)
+
+use crate::crdt::trigger::HLC_TIMESTAMP_COLUMN;
+use crate::database::error::DatabaseError;
+use sqlparser::ast::{Expr, Ident, Insert, SelectItem, SetExpr, Value};
+use uhlc::Timestamp;
+
+/// Helper-Struct für INSERT-Transformationen
+pub struct InsertTransformer {
+    hlc_timestamp_column: &'static str,
+}
+
+impl InsertTransformer {
+    pub fn new() -> Self {
+        Self {
+            hlc_timestamp_column: HLC_TIMESTAMP_COLUMN,
+        }
+    }
+
+    fn find_or_add_column(columns: &mut Vec<Ident>, col_name: &'static str) -> usize {
+        match columns.iter().position(|c| c.value == col_name) {
+            Some(index) => index, // Gefunden! Gib Index zurück.
+            None => {
+                // Nicht gefunden! Hinzufügen.
+                columns.push(Ident::new(col_name));
+                columns.len() - 1 // Der Index des gerade hinzugefügten Elements
+            }
+        }
+    }
+
+    /// Wenn der Index == der Länge ist, wird der Wert stattdessen gepusht.
+    fn set_or_push_value(row: &mut Vec<Expr>, index: usize, value: Expr) {
+        if index < row.len() {
+            // Spalte war vorhanden, Wert (wahrscheinlich `?` oder NULL) ersetzen
+            row[index] = value;
+        } else {
+            // Spalte war nicht vorhanden, Wert hinzufügen
+            row.push(value);
+        }
+    }
+
+    fn set_or_push_projection(projection: &mut Vec<SelectItem>, index: usize, value: Expr) {
+        let item = SelectItem::UnnamedExpr(value);
+        if index < projection.len() {
+            projection[index] = item;
+        } else {
+            projection.push(item);
+        }
+    }
+
+    /// Transformiert INSERT-Statements (fügt HLC-Timestamp hinzu)
+    /// Hard Delete: Kein ON CONFLICT mehr nötig - gelöschte Einträge sind wirklich weg
+    pub fn transform_insert(
+        &self,
+        insert_stmt: &mut Insert,
+        timestamp: &Timestamp,
+    ) -> Result<(), DatabaseError> {
+        // Add haex_timestamp  column if not exists
+        let hlc_col_index =
+            Self::find_or_add_column(&mut insert_stmt.columns, self.hlc_timestamp_column);
+
+        // ON CONFLICT Logik komplett entfernt!
+        // Bei Hard Deletes gibt es keine Tombstone-Einträge mehr zu reaktivieren
+        // UNIQUE Constraint Violations sind echte Fehler
+
+        match insert_stmt.source.as_mut() {
+            Some(query) => match &mut *query.body {
+                SetExpr::Values(values) => {
+                    for row in &mut values.rows {
+                        let hlc_value =
+                            Expr::Value(Value::SingleQuotedString(timestamp.to_string()).into());
+
+                        Self::set_or_push_value(row, hlc_col_index, hlc_value);
+                    }
+                }
+                SetExpr::Select(select) => {
+                    let hlc_value =
+                        Expr::Value(Value::SingleQuotedString(timestamp.to_string()).into());
+
+                    Self::set_or_push_projection(&mut select.projection, hlc_col_index, hlc_value);
+                }
+                _ => {
+                    return Err(DatabaseError::UnsupportedStatement {
+                        sql: insert_stmt.to_string(),
+                        reason: "INSERT with unsupported source type".to_string(),
+                    });
+                }
+            },
+            None => {
+                return Err(DatabaseError::UnsupportedStatement {
+                    reason: "INSERT statement has no source".to_string(),
+                    sql: insert_stmt.to_string(),
+                });
+            }
+        }
+        Ok(())
+    }
+}

src-tauri/src/crdt/mod.rs

@@ -1,3 +1,5 @@
 pub mod hlc;
+pub mod insert_transformer;
+//pub mod query_transformer;
 pub mod transformer;
 pub mod trigger;

src-tauri/src/crdt/transformer.rs

@@ -1,9 +1,12 @@
-use crate::crdt::trigger::{HLC_TIMESTAMP_COLUMN, TOMBSTONE_COLUMN};
+// src-tauri/src/crdt/transformer.rs
+
+use crate::crdt::insert_transformer::InsertTransformer;
+use crate::crdt::trigger::HLC_TIMESTAMP_COLUMN;
 use crate::database::error::DatabaseError;
 use crate::table_names::{TABLE_CRDT_CONFIGS, TABLE_CRDT_LOGS};
 use sqlparser::ast::{
-    Assignment, AssignmentTarget, BinaryOperator, ColumnDef, DataType, Expr, Ident, Insert,
+    Assignment, AssignmentTarget, ColumnDef, DataType, Expr, Ident, ObjectName, ObjectNamePart,
-    ObjectName, ObjectNamePart, SelectItem, SetExpr, Statement, TableFactor, TableObject, Value,
+    Statement, TableFactor, TableObject, Value,
 };
 use std::borrow::Cow;
 use std::collections::HashSet;
@@ -12,46 +15,14 @@ use uhlc::Timestamp;
 /// Konfiguration für CRDT-Spalten
 #[derive(Clone)]
 struct CrdtColumns {
-    tombstone: &'static str,
     hlc_timestamp: &'static str,
 }
 
 impl CrdtColumns {
     const DEFAULT: Self = Self {
-        tombstone: TOMBSTONE_COLUMN,
         hlc_timestamp: HLC_TIMESTAMP_COLUMN,
     };
 
-    /// Erstellt einen Tombstone-Filter für eine Tabelle
-    fn create_tombstone_filter(&self, table_alias: Option<&str>) -> Expr {
-        let column_expr = match table_alias {
-            Some(alias) => {
-                // Qualifizierte Referenz: alias.tombstone
-                Expr::CompoundIdentifier(vec![Ident::new(alias), Ident::new(self.tombstone)])
-            }
-            None => {
-                // Einfache Referenz: tombstone
-                Expr::Identifier(Ident::new(self.tombstone))
-            }
-        };
-
-        Expr::BinaryOp {
-            left: Box::new(column_expr),
-            op: BinaryOperator::NotEq,
-            right: Box::new(Expr::Value(Value::Number("1".to_string(), false).into())),
-        }
-    }
-
-    /// Erstellt eine Tombstone-Zuweisung für UPDATE/DELETE
-    fn create_tombstone_assignment(&self) -> Assignment {
-        Assignment {
-            target: AssignmentTarget::ColumnName(ObjectName(vec![ObjectNamePart::Identifier(
-                Ident::new(self.tombstone),
-            )])),
-            value: Expr::Value(Value::Number("1".to_string(), false).into()),
-        }
-    }
-
     /// Erstellt eine HLC-Zuweisung für UPDATE/DELETE
     fn create_hlc_assignment(&self, timestamp: &Timestamp) -> Assignment {
         Assignment {
@@ -64,13 +35,6 @@ impl CrdtColumns {
 
     /// Fügt CRDT-Spalten zu einer Tabellendefinition hinzu
     fn add_to_table_definition(&self, columns: &mut Vec<ColumnDef>) {
-        if !columns.iter().any(|c| c.name.value == self.tombstone) {
-            columns.push(ColumnDef {
-                name: Ident::new(self.tombstone),
-                data_type: DataType::Integer(None),
-                options: vec![],
-            });
-        }
         if !columns.iter().any(|c| c.name.value == self.hlc_timestamp) {
             columns.push(ColumnDef {
                 name: Ident::new(self.hlc_timestamp),
@@ -110,14 +74,61 @@ impl CrdtTransformer {
         Cow::Owned(name_str.trim_matches('`').trim_matches('"').to_string())
     }
 
-    pub fn transform_select_statement(&self, stmt: &mut Statement) -> Result<(), DatabaseError> {
+    // =================================================================
+    // ÖFFENTLICHE API-METHODEN
+    // =================================================================
+
+    pub fn transform_execute_statement_with_table_info(
+        &self,
+        stmt: &mut Statement,
+        hlc_timestamp: &Timestamp,
+    ) -> Result<Option<String>, DatabaseError> {
         match stmt {
-            Statement::Query(query) => self.transform_query_recursive(query),
+            Statement::CreateTable(create_table) => {
-            // Fange alle anderen Fälle ab und gib einen Fehler zurück
+                if self.is_crdt_sync_table(&create_table.name) {
-            _ => Err(DatabaseError::UnsupportedStatement {
+                    self.columns
-                sql: stmt.to_string(),
+                        .add_to_table_definition(&mut create_table.columns);
-                reason: "This operation only accepts SELECT statements.".to_string(),
+                    Ok(Some(
-            }),
+                        self.normalize_table_name(&create_table.name).into_owned(),
+                    ))
+                } else {
+                    Ok(None)
+                }
+            }
+            Statement::Insert(insert_stmt) => {
+                if let TableObject::TableName(name) = &insert_stmt.table {
+                    if self.is_crdt_sync_table(name) {
+                        // Hard Delete: Kein Schema-Lookup mehr nötig (kein ON CONFLICT)
+                        let insert_transformer = InsertTransformer::new();
+                        insert_transformer.transform_insert(insert_stmt, hlc_timestamp)?;
+                    }
+                }
+                Ok(None)
+            }
+            Statement::Update {
+                table, assignments, ..
+            } => {
+                if let TableFactor::Table { name, .. } = &table.relation {
+                    if self.is_crdt_sync_table(name) {
+                        assignments.push(self.columns.create_hlc_assignment(hlc_timestamp));
+                    }
+                }
+                Ok(None)
+            }
+            Statement::Delete(_del_stmt) => {
+                // Hard Delete - keine Transformation!
+                // DELETE bleibt DELETE
+                // BEFORE DELETE Trigger schreiben die Logs
+                Ok(None)
+            }
+            Statement::AlterTable { name, .. } => {
+                if self.is_crdt_sync_table(name) {
+                    Ok(Some(self.normalize_table_name(name).into_owned()))
+                } else {
+                    Ok(None)
+                }
+            }
+            _ => Ok(None),
         }
     }
 
@@ -141,7 +152,9 @@ impl CrdtTransformer {
             Statement::Insert(insert_stmt) => {
                 if let TableObject::TableName(name) = &insert_stmt.table {
                     if self.is_crdt_sync_table(name) {
-                        self.transform_insert(insert_stmt, hlc_timestamp)?;
+                        // Hard Delete: Keine ON CONFLICT Logik mehr nötig
+                        let insert_transformer = InsertTransformer::new();
+                        insert_transformer.transform_insert(insert_stmt, hlc_timestamp)?;
                     }
                 }
                 Ok(None)
@@ -156,18 +169,10 @@ impl CrdtTransformer {
                 }
                 Ok(None)
             }
-            Statement::Delete(del_stmt) => {
+            Statement::Delete(_del_stmt) => {
-                if let Some(table_name) = self.extract_table_name_from_delete(del_stmt) {
+                // Hard Delete - keine Transformation!
-                    if self.is_crdt_sync_table(&table_name) {
+                // DELETE bleibt DELETE
-                        self.transform_delete_to_update(stmt, hlc_timestamp)?;
+                Ok(None)
-                    }
-                    Ok(None)
-                } else {
-                    Err(DatabaseError::UnsupportedStatement {
-                        sql: del_stmt.to_string(),
-                        reason: "DELETE from non-table source or multiple tables".to_string(),
-                    })
-                }
             }
             Statement::AlterTable { name, .. } => {
                 if self.is_crdt_sync_table(name) {
@@ -179,606 +184,4 @@ impl CrdtTransformer {
             _ => Ok(None),
         }
     }
-
-    /// Transformiert Query-Statements (fügt Tombstone-Filter hinzu)
-    fn transform_query_recursive(
-        &self,
-        query: &mut sqlparser::ast::Query,
-    ) -> Result<(), DatabaseError> {
-        self.add_tombstone_filters_recursive(&mut query.body)
-    }
-
-    /// Rekursive Behandlung aller SetExpr-Typen mit vollständiger Subquery-Unterstützung
-    fn add_tombstone_filters_recursive(&self, set_expr: &mut SetExpr) -> Result<(), DatabaseError> {
-        match set_expr {
-            SetExpr::Select(select) => {
-                self.add_tombstone_filters_to_select(select)?;
-
-                // Transformiere auch Subqueries in Projektionen
-                for projection in &mut select.projection {
-                    match projection {
-                        SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } => {
-                            self.transform_expression_subqueries(expr)?;
-                        }
-                        _ => {} // Wildcard projections ignorieren
-                    }
-                }
-
-                // Transformiere Subqueries in WHERE
-                if let Some(where_clause) = &mut select.selection {
-                    self.transform_expression_subqueries(where_clause)?;
-                }
-
-                // Transformiere Subqueries in GROUP BY
-                match &mut select.group_by {
-                    sqlparser::ast::GroupByExpr::All(_) => {
-                        // GROUP BY ALL - keine Expressions zu transformieren
-                    }
-                    sqlparser::ast::GroupByExpr::Expressions(exprs, _) => {
-                        for group_expr in exprs {
-                            self.transform_expression_subqueries(group_expr)?;
-                        }
-                    }
-                }
-
-                // Transformiere Subqueries in HAVING
-                if let Some(having) = &mut select.having {
-                    self.transform_expression_subqueries(having)?;
-                }
-            }
-            SetExpr::SetOperation { left, right, .. } => {
-                self.add_tombstone_filters_recursive(left)?;
-                self.add_tombstone_filters_recursive(right)?;
-            }
-            SetExpr::Query(query) => {
-                self.add_tombstone_filters_recursive(&mut query.body)?;
-            }
-            SetExpr::Values(values) => {
-                // Transformiere auch Subqueries in Values-Listen
-                for row in &mut values.rows {
-                    for expr in row {
-                        self.transform_expression_subqueries(expr)?;
-                    }
-                }
-            }
-            _ => {} // Andere Fälle
-        }
-        Ok(())
-    }
-
-    /// Transformiert Subqueries innerhalb von Expressions
-    fn transform_expression_subqueries(&self, expr: &mut Expr) -> Result<(), DatabaseError> {
-        match expr {
-            // Einfache Subqueries
-            Expr::Subquery(query) => {
-                self.add_tombstone_filters_recursive(&mut query.body)?;
-            }
-            // EXISTS Subqueries
-            Expr::Exists { subquery, .. } => {
-                self.add_tombstone_filters_recursive(&mut subquery.body)?;
-            }
-            // IN Subqueries
-            Expr::InSubquery {
-                expr: left_expr,
-                subquery,
-                ..
-            } => {
-                self.transform_expression_subqueries(left_expr)?;
-                self.add_tombstone_filters_recursive(&mut subquery.body)?;
-            }
-            // ANY/ALL Subqueries
-            Expr::AnyOp { left, right, .. } | Expr::AllOp { left, right, .. } => {
-                self.transform_expression_subqueries(left)?;
-                self.transform_expression_subqueries(right)?;
-            }
-            // Binäre Operationen
-            Expr::BinaryOp { left, right, .. } => {
-                self.transform_expression_subqueries(left)?;
-                self.transform_expression_subqueries(right)?;
-            }
-            // Unäre Operationen
-            Expr::UnaryOp {
-                expr: inner_expr, ..
-            } => {
-                self.transform_expression_subqueries(inner_expr)?;
-            }
-            // Verschachtelte Ausdrücke
-            Expr::Nested(nested) => {
-                self.transform_expression_subqueries(nested)?;
-            }
-            // CASE-Ausdrücke
-            Expr::Case {
-                operand,
-                conditions,
-                else_result,
-                ..
-            } => {
-                if let Some(op) = operand {
-                    self.transform_expression_subqueries(op)?;
-                }
-                for case_when in conditions {
-                    self.transform_expression_subqueries(&mut case_when.condition)?;
-                    self.transform_expression_subqueries(&mut case_when.result)?;
-                }
-                if let Some(else_res) = else_result {
-                    self.transform_expression_subqueries(else_res)?;
-                }
-            }
-            // Funktionsaufrufe
-            Expr::Function(func) => match &mut func.args {
-                sqlparser::ast::FunctionArguments::List(sqlparser::ast::FunctionArgumentList {
-                    args,
-                    ..
-                }) => {
-                    for arg in args {
-                        if let sqlparser::ast::FunctionArg::Unnamed(
-                            sqlparser::ast::FunctionArgExpr::Expr(expr),
-                        ) = arg
-                        {
-                            self.transform_expression_subqueries(expr)?;
-                        }
-                    }
-                }
-                _ => {}
-            },
-            // BETWEEN
-            Expr::Between {
-                expr: main_expr,
-                low,
-                high,
-                ..
-            } => {
-                self.transform_expression_subqueries(main_expr)?;
-                self.transform_expression_subqueries(low)?;
-                self.transform_expression_subqueries(high)?;
-            }
-            // IN Liste
-            Expr::InList {
-                expr: main_expr,
-                list,
-                ..
-            } => {
-                self.transform_expression_subqueries(main_expr)?;
-                for list_expr in list {
-                    self.transform_expression_subqueries(list_expr)?;
-                }
-            }
-            // IS NULL/IS NOT NULL
-            Expr::IsNull(inner) | Expr::IsNotNull(inner) => {
-                self.transform_expression_subqueries(inner)?;
-            }
-            // Andere Expression-Typen benötigen keine Transformation
-            _ => {}
-        }
-        Ok(())
-    }
-
-    /// Fügt Tombstone-Filter zu SELECT-Statements hinzu (nur wenn nicht explizit in WHERE gesetzt)
-    fn add_tombstone_filters_to_select(
-        &self,
-        select: &mut sqlparser::ast::Select,
-    ) -> Result<(), DatabaseError> {
-        // Sammle alle CRDT-Tabellen mit ihren Aliasen
-        let mut crdt_tables = Vec::new();
-        for twj in &select.from {
-            if let TableFactor::Table { name, alias, .. } = &twj.relation {
-                if self.is_crdt_sync_table(name) {
-                    let table_alias = alias.as_ref().map(|a| a.name.value.as_str());
-                    crdt_tables.push((name.clone(), table_alias));
-                }
-            }
-        }
-
-        if crdt_tables.is_empty() {
-            return Ok(());
-        }
-
-        // Prüfe, welche Tombstone-Spalten bereits in der WHERE-Klausel referenziert werden
-        let explicitly_filtered_tables = if let Some(where_clause) = &select.selection {
-            self.find_explicitly_filtered_tombstone_tables(where_clause, &crdt_tables)
-        } else {
-            HashSet::new()
-        };
-
-        // Erstelle Filter nur für Tabellen, die noch nicht explizit gefiltert werden
-        let mut tombstone_filters = Vec::new();
-        for (table_name, table_alias) in crdt_tables {
-            let table_name_string = table_name.to_string();
-            let table_key = table_alias.unwrap_or(&table_name_string);
-            if !explicitly_filtered_tables.contains(table_key) {
-                tombstone_filters.push(self.columns.create_tombstone_filter(table_alias));
-            }
-        }
-
-        // Füge die automatischen Filter hinzu
-        if !tombstone_filters.is_empty() {
-            let combined_filter = tombstone_filters
-                .into_iter()
-                .reduce(|acc, expr| Expr::BinaryOp {
-                    left: Box::new(acc),
-                    op: BinaryOperator::And,
-                    right: Box::new(expr),
-                })
-                .unwrap();
-
-            match &mut select.selection {
-                Some(existing) => {
-                    *existing = Expr::BinaryOp {
-                        left: Box::new(existing.clone()),
-                        op: BinaryOperator::And,
-                        right: Box::new(combined_filter),
-                    };
-                }
-                None => {
-                    select.selection = Some(combined_filter);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Findet alle Tabellen, die bereits explizit Tombstone-Filter in der WHERE-Klausel haben
-    fn find_explicitly_filtered_tombstone_tables(
-        &self,
-        where_expr: &Expr,
-        crdt_tables: &[(ObjectName, Option<&str>)],
-    ) -> HashSet<String> {
-        let mut filtered_tables = HashSet::new();
-        self.scan_expression_for_tombstone_references(
-            where_expr,
-            crdt_tables,
-            &mut filtered_tables,
-        );
-        filtered_tables
-    }
-
-    /// Rekursiv durchsucht einen Expression-Baum nach Tombstone-Spalten-Referenzen
-    fn scan_expression_for_tombstone_references(
-        &self,
-        expr: &Expr,
-        crdt_tables: &[(ObjectName, Option<&str>)],
-        filtered_tables: &mut HashSet<String>,
-    ) {
-        match expr {
-            // Einfache Spaltenreferenz: tombstone = ?
-            Expr::Identifier(ident) => {
-                if ident.value == self.columns.tombstone {
-                    // Wenn keine Tabelle spezifiziert ist und es nur eine CRDT-Tabelle gibt
-                    if crdt_tables.len() == 1 {
-                        let table_name_str = crdt_tables[0].0.to_string();
-                        let table_key = crdt_tables[0].1.unwrap_or(&table_name_str);
-                        filtered_tables.insert(table_key.to_string());
-                    }
-                }
-            }
-            // Qualifizierte Spaltenreferenz: table.tombstone = ? oder alias.tombstone = ?
-            Expr::CompoundIdentifier(idents) => {
-                if idents.len() == 2 && idents[1].value == self.columns.tombstone {
-                    let table_ref = &idents[0].value;
-
-                    // Prüfe, ob es eine unserer CRDT-Tabellen ist (nach Name oder Alias)
-                    for (table_name, alias) in crdt_tables {
-                        let table_name_str = table_name.to_string();
-                        if table_ref == &table_name_str || alias.map_or(false, |a| a == table_ref) {
-                            filtered_tables.insert(table_ref.clone());
-                            break;
-                        }
-                    }
-                }
-            }
-            // Binäre Operationen: AND, OR, etc.
-            Expr::BinaryOp { left, right, .. } => {
-                self.scan_expression_for_tombstone_references(left, crdt_tables, filtered_tables);
-                self.scan_expression_for_tombstone_references(right, crdt_tables, filtered_tables);
-            }
-            // Unäre Operationen: NOT, etc.
-            Expr::UnaryOp { expr, .. } => {
-                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
-            }
-            // Verschachtelte Ausdrücke
-            Expr::Nested(nested) => {
-                self.scan_expression_for_tombstone_references(nested, crdt_tables, filtered_tables);
-            }
-            // IN-Klauseln
-            Expr::InList { expr, .. } => {
-                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
-            }
-            // BETWEEN-Klauseln
-            Expr::Between { expr, .. } => {
-                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
-            }
-            // IS NULL/IS NOT NULL
-            Expr::IsNull(expr) | Expr::IsNotNull(expr) => {
-                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
-            }
-            // Funktionsaufrufe - KORRIGIERT
-            Expr::Function(func) => {
-                match &func.args {
-                    sqlparser::ast::FunctionArguments::List(
-                        sqlparser::ast::FunctionArgumentList { args, .. },
-                    ) => {
-                        for arg in args {
-                            if let sqlparser::ast::FunctionArg::Unnamed(
-                                sqlparser::ast::FunctionArgExpr::Expr(expr),
-                            ) = arg
-                            {
-                                self.scan_expression_for_tombstone_references(
-                                    expr,
-                                    crdt_tables,
-                                    filtered_tables,
-                                );
-                            }
-                        }
-                    }
-                    _ => {} // Andere FunctionArguments-Varianten ignorieren
-                }
-            }
-            // CASE-Ausdrücke - KORRIGIERT
-            Expr::Case {
-                operand,
-                conditions,
-                else_result,
-                ..
-            } => {
-                if let Some(op) = operand {
-                    self.scan_expression_for_tombstone_references(op, crdt_tables, filtered_tables);
-                }
-                for case_when in conditions {
-                    self.scan_expression_for_tombstone_references(
-                        &case_when.condition,
-                        crdt_tables,
-                        filtered_tables,
-                    );
-                    self.scan_expression_for_tombstone_references(
-                        &case_when.result,
-                        crdt_tables,
-                        filtered_tables,
-                    );
-                }
-                if let Some(else_res) = else_result {
-                    self.scan_expression_for_tombstone_references(
-                        else_res,
-                        crdt_tables,
-                        filtered_tables,
-                    );
-                }
-            }
-            // Subqueries mit vollständiger Unterstützung
-            Expr::Subquery(query) => {
-                self.transform_query_recursive_for_tombstone_analysis(
-                    query,
-                    crdt_tables,
-                    filtered_tables,
-                )
-                .ok();
-            }
-            // EXISTS/NOT EXISTS Subqueries
-            Expr::Exists { subquery, .. } => {
-                self.transform_query_recursive_for_tombstone_analysis(
-                    subquery,
-                    crdt_tables,
-                    filtered_tables,
-                )
-                .ok();
-            }
-            // IN/NOT IN Subqueries
-            Expr::InSubquery { expr, subquery, .. } => {
-                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
-                self.transform_query_recursive_for_tombstone_analysis(
-                    subquery,
-                    crdt_tables,
-                    filtered_tables,
-                )
-                .ok();
-            }
-            // ANY/ALL Subqueries
-            Expr::AnyOp { left, right, .. } | Expr::AllOp { left, right, .. } => {
-                self.scan_expression_for_tombstone_references(left, crdt_tables, filtered_tables);
-                self.scan_expression_for_tombstone_references(right, crdt_tables, filtered_tables);
-            }
-            // Andere Expression-Typen ignorieren wir für jetzt
-            _ => {}
-        }
-    }
-
-    /// Analysiert eine Subquery und sammelt Tombstone-Referenzen
-    fn transform_query_recursive_for_tombstone_analysis(
-        &self,
-        query: &sqlparser::ast::Query,
-        crdt_tables: &[(ObjectName, Option<&str>)],
-        filtered_tables: &mut HashSet<String>,
-    ) -> Result<(), DatabaseError> {
-        self.analyze_set_expr_for_tombstone_references(&query.body, crdt_tables, filtered_tables)
-    }
-
-    /// Rekursiv analysiert SetExpr für Tombstone-Referenzen
-    fn analyze_set_expr_for_tombstone_references(
-        &self,
-        set_expr: &SetExpr,
-        crdt_tables: &[(ObjectName, Option<&str>)],
-        filtered_tables: &mut HashSet<String>,
-    ) -> Result<(), DatabaseError> {
-        match set_expr {
-            SetExpr::Select(select) => {
-                // Analysiere WHERE-Klausel
-                if let Some(where_clause) = &select.selection {
-                    self.scan_expression_for_tombstone_references(
-                        where_clause,
-                        crdt_tables,
-                        filtered_tables,
-                    );
-                }
-
-                // Analysiere alle Projektionen (können auch Subqueries enthalten)
-                for projection in &select.projection {
-                    match projection {
-                        SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } => {
-                            self.scan_expression_for_tombstone_references(
-                                expr,
-                                crdt_tables,
-                                filtered_tables,
-                            );
-                        }
-                        _ => {} // Wildcard projections ignorieren
-                    }
-                }
-
-                // Analysiere GROUP BY
-                match &select.group_by {
-                    sqlparser::ast::GroupByExpr::All(_) => {
-                        // GROUP BY ALL - keine Expressions zu analysieren
-                    }
-                    sqlparser::ast::GroupByExpr::Expressions(exprs, _) => {
-                        for group_expr in exprs {
-                            self.scan_expression_for_tombstone_references(
-                                group_expr,
-                                crdt_tables,
-                                filtered_tables,
-                            );
-                        }
-                    }
-                }
-
-                // Analysiere HAVING
-                if let Some(having) = &select.having {
-                    self.scan_expression_for_tombstone_references(
-                        having,
-                        crdt_tables,
-                        filtered_tables,
-                    );
-                }
-            }
-            SetExpr::SetOperation { left, right, .. } => {
-                self.analyze_set_expr_for_tombstone_references(left, crdt_tables, filtered_tables)?;
-                self.analyze_set_expr_for_tombstone_references(
-                    right,
-                    crdt_tables,
-                    filtered_tables,
-                )?;
-            }
-            SetExpr::Query(query) => {
-                self.analyze_set_expr_for_tombstone_references(
-                    &query.body,
-                    crdt_tables,
-                    filtered_tables,
-                )?;
-            }
-            SetExpr::Values(values) => {
-                // Analysiere Values-Listen
-                for row in &values.rows {
-                    for expr in row {
-                        self.scan_expression_for_tombstone_references(
-                            expr,
-                            crdt_tables,
-                            filtered_tables,
-                        );
-                    }
-                }
-            }
-            _ => {} // Andere Varianten
-        }
-        Ok(())
-    }
-
-    /// Transformiert INSERT-Statements (fügt HLC-Timestamp hinzu)
-    fn transform_insert(
-        &self,
-        insert_stmt: &mut Insert,
-        timestamp: &Timestamp,
-    ) -> Result<(), DatabaseError> {
-        insert_stmt
-            .columns
-            .push(Ident::new(self.columns.hlc_timestamp));
-
-        match insert_stmt.source.as_mut() {
-            Some(query) => match &mut *query.body {
-                SetExpr::Values(values) => {
-                    for row in &mut values.rows {
-                        row.push(Expr::Value(
-                            Value::SingleQuotedString(timestamp.to_string()).into(),
-                        ));
-                    }
-                }
-                SetExpr::Select(select) => {
-                    let hlc_expr =
-                        Expr::Value(Value::SingleQuotedString(timestamp.to_string()).into());
-                    select.projection.push(SelectItem::UnnamedExpr(hlc_expr));
-                }
-                _ => {
-                    return Err(DatabaseError::UnsupportedStatement {
-                        sql: insert_stmt.to_string(),
-                        reason: "INSERT with unsupported source type".to_string(),
-                    });
-                }
-            },
-            None => {
-                return Err(DatabaseError::UnsupportedStatement {
-                    reason: "INSERT statement has no source".to_string(),
-                    sql: insert_stmt.to_string(),
-                });
-            }
-        }
-        Ok(())
-    }
-
-    /// Transformiert DELETE zu UPDATE (soft delete)
-    fn transform_delete_to_update(
-        &self,
-        stmt: &mut Statement,
-        timestamp: &Timestamp,
-    ) -> Result<(), DatabaseError> {
-        if let Statement::Delete(del_stmt) = stmt {
-            let table_to_update = match &del_stmt.from {
-                sqlparser::ast::FromTable::WithFromKeyword(from)
-                | sqlparser::ast::FromTable::WithoutKeyword(from) => {
-                    if from.len() == 1 {
-                        from[0].clone()
-                    } else {
-                        return Err(DatabaseError::UnsupportedStatement {
-                            reason: "DELETE with multiple tables not supported".to_string(),
-                            sql: stmt.to_string(),
-                        });
-                    }
-                }
-            };
-
-            let assignments = vec![
-                self.columns.create_tombstone_assignment(),
-                self.columns.create_hlc_assignment(timestamp),
-            ];
-
-            *stmt = Statement::Update {
-                table: table_to_update,
-                assignments,
-                from: None,
-                selection: del_stmt.selection.clone(),
-                returning: None,
-                or: None,
-                limit: None,
-            };
-        }
-        Ok(())
-    }
-
-    /// Extrahiert Tabellennamen aus DELETE-Statement
-    fn extract_table_name_from_delete(
-        &self,
-        del_stmt: &sqlparser::ast::Delete,
-    ) -> Option<ObjectName> {
-        let tables = match &del_stmt.from {
-            sqlparser::ast::FromTable::WithFromKeyword(from)
-            | sqlparser::ast::FromTable::WithoutKeyword(from) => from,
-        };
-
-        if tables.len() == 1 {
-            if let TableFactor::Table { name, .. } = &tables[0].relation {
-                Some(name.clone())
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
 }

src-tauri/src/crdt/trigger.rs

@@ -9,20 +9,17 @@ use ts_rs::TS;
 // Der "z_"-Präfix soll sicherstellen, dass diese Trigger als Letzte ausgeführt werden
 const INSERT_TRIGGER_TPL: &str = "z_crdt_{TABLE_NAME}_insert";
 const UPDATE_TRIGGER_TPL: &str = "z_crdt_{TABLE_NAME}_update";
+const DELETE_TRIGGER_TPL: &str = "z_crdt_{TABLE_NAME}_delete";
 
-//const SYNC_ACTIVE_KEY: &str = "sync_active";
-pub const TOMBSTONE_COLUMN: &str = "haex_tombstone";
 pub const HLC_TIMESTAMP_COLUMN: &str = "haex_timestamp";
 
+/// Name der custom UUID-Generierungs-Funktion (registriert in database::core::open_and_init_db)
+pub const UUID_FUNCTION_NAME: &str = "gen_uuid";
+
 #[derive(Debug)]
 pub enum CrdtSetupError {
     /// Kapselt einen Fehler, der von der rusqlite-Bibliothek kommt.
     DatabaseError(rusqlite::Error),
-    /// Die Tabelle hat keine Tombstone-Spalte, was eine CRDT-Voraussetzung ist.
-    TombstoneColumnMissing {
-        table_name: String,
-        column_name: String,
-    },
     HlcColumnMissing {
         table_name: String,
         column_name: String,
@@ -36,14 +33,6 @@ impl Display for CrdtSetupError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             CrdtSetupError::DatabaseError(e) => write!(f, "Database error: {}", e),
-            CrdtSetupError::TombstoneColumnMissing {
-                table_name,
-                column_name,
-            } => write!(
-                f,
-                "Table '{}' is missing the required tombstone column '{}'",
-                table_name, column_name
-            ),
             CrdtSetupError::HlcColumnMissing {
                 table_name,
                 column_name,
@@ -78,14 +67,14 @@ pub enum TriggerSetupResult {
     TableNotFound,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
-struct ColumnInfo {
+pub struct ColumnInfo {
-    name: String,
+    pub name: String,
-    is_pk: bool,
+    pub is_pk: bool,
 }
 
 impl ColumnInfo {
-    fn from_row(row: &Row) -> RusqliteResult<Self> {
+    pub fn from_row(row: &Row) -> RusqliteResult<Self> {
         Ok(ColumnInfo {
             name: row.get("name")?,
             is_pk: row.get::<_, i64>("pk")? > 0,
@@ -94,7 +83,8 @@ impl ColumnInfo {
 }
 
 fn is_safe_identifier(name: &str) -> bool {
-    !name.is_empty() && name.chars().all(|c| c.is_alphanumeric() || c == '_')
+    // Allow alphanumeric characters, underscores, and hyphens (for extension names like "nuxt-app")
+    !name.is_empty() && name.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-')
 }
 
 /// Richtet CRDT-Trigger für eine einzelne Tabelle ein.
@@ -109,13 +99,6 @@ pub fn setup_triggers_for_table(
         return Ok(TriggerSetupResult::TableNotFound);
     }
 
-    if !columns.iter().any(|c| c.name == TOMBSTONE_COLUMN) {
-        return Err(CrdtSetupError::TombstoneColumnMissing {
-            table_name: table_name.to_string(),
-            column_name: TOMBSTONE_COLUMN.to_string(),
-        });
-    }
-
     if !columns.iter().any(|c| c.name == HLC_TIMESTAMP_COLUMN) {
         return Err(CrdtSetupError::HlcColumnMissing {
             table_name: table_name.to_string(),
@@ -137,12 +120,13 @@ pub fn setup_triggers_for_table(
 
     let cols_to_track: Vec<String> = columns
         .iter()
-        .filter(|c| !c.is_pk) //&& c.name != TOMBSTONE_COLUMN && c.name != HLC_TIMESTAMP_COLUMN
+        .filter(|c| !c.is_pk)
         .map(|c| c.name.clone())
         .collect();
 
     let insert_trigger_sql = generate_insert_trigger_sql(table_name, &pks, &cols_to_track);
     let update_trigger_sql = generate_update_trigger_sql(table_name, &pks, &cols_to_track);
+    let delete_trigger_sql = generate_delete_trigger_sql(table_name, &pks, &cols_to_track);
 
     if recreate {
         drop_triggers_for_table(&tx, table_name)?;
@@ -150,12 +134,13 @@ pub fn setup_triggers_for_table(
 
     tx.execute_batch(&insert_trigger_sql)?;
     tx.execute_batch(&update_trigger_sql)?;
+    tx.execute_batch(&delete_trigger_sql)?;
 
     Ok(TriggerSetupResult::Success)
 }
 
 /// Holt das Schema für eine gegebene Tabelle.
-fn get_table_schema(conn: &Connection, table_name: &str) -> RusqliteResult<Vec<ColumnInfo>> {
+pub fn get_table_schema(conn: &Connection, table_name: &str) -> RusqliteResult<Vec<ColumnInfo>> {
     if !is_safe_identifier(table_name) {
         return Err(rusqlite::Error::InvalidParameterName(format!(
             "Invalid or unsafe table name provided: {}",
@@ -170,6 +155,8 @@ fn get_table_schema(conn: &Connection, table_name: &str) -> RusqliteResult<Vec<C
     rows.collect()
 }
 
+// get_foreign_key_columns() removed - not needed with hard deletes (no ON CONFLICT logic)
+
 pub fn drop_triggers_for_table(
     tx: &Transaction, // Arbeitet direkt auf einer Transaktion
     table_name: &str,
@@ -186,8 +173,13 @@ pub fn drop_triggers_for_table(
         drop_trigger_sql(INSERT_TRIGGER_TPL.replace("{TABLE_NAME}", table_name));
     let drop_update_trigger_sql =
         drop_trigger_sql(UPDATE_TRIGGER_TPL.replace("{TABLE_NAME}", table_name));
+    let drop_delete_trigger_sql =
+        drop_trigger_sql(DELETE_TRIGGER_TPL.replace("{TABLE_NAME}", table_name));
 
-    let sql_batch = format!("{}\n{}", drop_insert_trigger_sql, drop_update_trigger_sql);
+    let sql_batch = format!(
+        "{}\n{}\n{}",
+        drop_insert_trigger_sql, drop_update_trigger_sql, drop_delete_trigger_sql
+    );
 
     tx.execute_batch(&sql_batch)?;
     Ok(())
@@ -259,9 +251,10 @@ fn generate_insert_trigger_sql(table_name: &str, pks: &[String], cols: &[String]
     let column_inserts = if cols.is_empty() {
         // Nur PKs -> einfacher Insert ins Log
         format!(
-            "INSERT INTO {log_table} (haex_timestamp, op_type, table_name, row_pks)
+            "INSERT INTO {log_table} (id, haex_timestamp, op_type, table_name, row_pks)
-            VALUES (NEW.\"{hlc_col}\", 'INSERT', '{table}', json_object({pk_payload}));",
+            VALUES ({uuid_fn}(), NEW.\"{hlc_col}\", 'INSERT', '{table}', json_object({pk_payload}));",
             log_table = TABLE_CRDT_LOGS,
+            uuid_fn = UUID_FUNCTION_NAME,
             hlc_col = HLC_TIMESTAMP_COLUMN,
             table = table_name,
             pk_payload = pk_json_payload
@@ -270,9 +263,10 @@ fn generate_insert_trigger_sql(table_name: &str, pks: &[String], cols: &[String]
         cols.iter().fold(String::new(), |mut acc, col| {
             writeln!(
                 &mut acc,
-                "INSERT INTO {log_table} (haex_timestamp, op_type, table_name, row_pks, column_name, new_value)
+                "INSERT INTO {log_table} (id, haex_timestamp, op_type, table_name, row_pks, column_name, new_value)
-                VALUES (NEW.\"{hlc_col}\", 'INSERT', '{table}', json_object({pk_payload}), '{column}', json_object('value', NEW.\"{column}\"));",
+                VALUES ({uuid_fn}(), NEW.\"{hlc_col}\", 'INSERT', '{table}', json_object({pk_payload}), '{column}', json_object('value', NEW.\"{column}\"));",
                 log_table = TABLE_CRDT_LOGS,
+                uuid_fn = UUID_FUNCTION_NAME,
                 hlc_col = HLC_TIMESTAMP_COLUMN,
                 table = table_name,
                 pk_payload = pk_json_payload,
@@ -314,11 +308,12 @@ fn generate_update_trigger_sql(table_name: &str, pks: &[String], cols: &[String]
         for col in cols {
             writeln!(
                 &mut body,
-                "INSERT INTO {log_table} (haex_timestamp, op_type, table_name, row_pks, column_name, new_value, old_value)
+                "INSERT INTO {log_table} (id, haex_timestamp, op_type, table_name, row_pks, column_name, new_value, old_value)
-                    SELECT NEW.\"{hlc_col}\", 'UPDATE', '{table}', json_object({pk_payload}), '{column}',
+                    SELECT {uuid_fn}(), NEW.\"{hlc_col}\", 'UPDATE', '{table}', json_object({pk_payload}), '{column}',
                     json_object('value', NEW.\"{column}\"), json_object('value', OLD.\"{column}\")
                     WHERE NEW.\"{column}\" IS NOT OLD.\"{column}\";",
                 log_table = TABLE_CRDT_LOGS,
+                uuid_fn = UUID_FUNCTION_NAME,
                 hlc_col = HLC_TIMESTAMP_COLUMN,
                 table = table_name,
                 pk_payload = pk_json_payload,
@@ -327,19 +322,7 @@ fn generate_update_trigger_sql(table_name: &str, pks: &[String], cols: &[String]
         }
     }
 
-    // Soft-delete loggen
+    // Soft-delete Logging entfernt - wir nutzen jetzt Hard Deletes mit eigenem BEFORE DELETE Trigger
-    writeln!(
-        &mut body,
-        "INSERT INTO {log_table} (haex_timestamp, op_type, table_name, row_pks)
-            SELECT NEW.\"{hlc_col}\", 'DELETE', '{table}', json_object({pk_payload})
-            WHERE NEW.\"{tombstone_col}\" = 1 AND OLD.\"{tombstone_col}\" = 0;",
-        log_table = TABLE_CRDT_LOGS,
-        hlc_col = HLC_TIMESTAMP_COLUMN,
-        table = table_name,
-        pk_payload = pk_json_payload,
-        tombstone_col = TOMBSTONE_COLUMN
-    )
-    .unwrap();
 
     let trigger_name = UPDATE_TRIGGER_TPL.replace("{TABLE_NAME}", table_name);
 
@@ -352,3 +335,57 @@ fn generate_update_trigger_sql(table_name: &str, pks: &[String], cols: &[String]
             END;"
     )
 }
+
+/// Generiert das SQL für den BEFORE DELETE-Trigger.
+/// WICHTIG: BEFORE DELETE damit die Daten noch verfügbar sind!
+fn generate_delete_trigger_sql(table_name: &str, pks: &[String], cols: &[String]) -> String {
+    let pk_json_payload = pks
+        .iter()
+        .map(|pk| format!("'{}', OLD.\"{}\"", pk, pk))
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    let mut body = String::new();
+
+    // Alle Spaltenwerte speichern für mögliche Wiederherstellung
+    if !cols.is_empty() {
+        for col in cols {
+            writeln!(
+                &mut body,
+                "INSERT INTO {log_table} (id, haex_timestamp, op_type, table_name, row_pks, column_name, old_value)
+                    VALUES ({uuid_fn}(), OLD.\"{hlc_col}\", 'DELETE', '{table}', json_object({pk_payload}), '{column}',
+                    json_object('value', OLD.\"{column}\"));",
+                log_table = TABLE_CRDT_LOGS,
+                uuid_fn = UUID_FUNCTION_NAME,
+                hlc_col = HLC_TIMESTAMP_COLUMN,
+                table = table_name,
+                pk_payload = pk_json_payload,
+                column = col
+            ).unwrap();
+        }
+    } else {
+        // Nur PKs -> minimales Delete Log
+        writeln!(
+            &mut body,
+            "INSERT INTO {log_table} (id, haex_timestamp, op_type, table_name, row_pks)
+                VALUES ({uuid_fn}(), OLD.\"{hlc_col}\", 'DELETE', '{table}', json_object({pk_payload}));",
+            log_table = TABLE_CRDT_LOGS,
+            uuid_fn = UUID_FUNCTION_NAME,
+            hlc_col = HLC_TIMESTAMP_COLUMN,
+            table = table_name,
+            pk_payload = pk_json_payload
+        )
+        .unwrap();
+    }
+
+    let trigger_name = DELETE_TRIGGER_TPL.replace("{TABLE_NAME}", table_name);
+
+    format!(
+        "CREATE TRIGGER IF NOT EXISTS \"{trigger_name}\"
+            BEFORE DELETE ON \"{table_name}\"
+            FOR EACH ROW
+            BEGIN
+            {body}
+            END;"
+    )
+}

src-tauri/src/database/core.rs

@@ -1,21 +1,23 @@
 // src-tauri/src/database/core.rs
 
+use crate::crdt::trigger::UUID_FUNCTION_NAME;
 use crate::database::error::DatabaseError;
 use crate::database::DbConnection;
+use crate::extension::database::executor::SqlExecutor;
 use base64::{engine::general_purpose::STANDARD, Engine as _};
+use rusqlite::functions::FunctionFlags;
 use rusqlite::types::Value as SqlValue;
 use rusqlite::{
     types::{Value as RusqliteValue, ValueRef},
     Connection, OpenFlags, ToSql,
 };
 use serde_json::Value as JsonValue;
-use sqlparser::ast::{Query, Select, SetExpr, Statement, TableFactor, TableObject};
+use sqlparser::ast::{Expr, Query, Select, SetExpr, Statement, TableFactor, TableObject};
 use sqlparser::dialect::SQLiteDialect;
 use sqlparser::parser::Parser;
-use std::collections::HashMap;
+use uuid::Uuid;
 
 /// Öffnet und initialisiert eine Datenbank mit Verschlüsselung
-///
 pub fn open_and_init_db(path: &str, key: &str, create: bool) -> Result<Connection, DatabaseError> {
     let flags = if create {
         OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE
@@ -35,6 +37,19 @@ pub fn open_and_init_db(path: &str, key: &str, create: bool) -> Result<Connectio
             reason: e.to_string(),
         })?;
 
+    // Register custom UUID function for SQLite triggers
+    conn.create_scalar_function(
+        UUID_FUNCTION_NAME,
+        0,
+        FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+        |_ctx| {
+            Ok(Uuid::new_v4().to_string())
+        },
+    )
+    .map_err(|e| DatabaseError::DatabaseError {
+        reason: format!("Failed to register {} function: {}", UUID_FUNCTION_NAME, e),
+    })?;
+
     let journal_mode: String = conn
         .query_row("PRAGMA journal_mode=WAL;", [], |row| row.get(0))
         .map_err(|e| DatabaseError::PragmaError {
@@ -74,12 +89,29 @@ pub fn parse_single_statement(sql: &str) -> Result<Statement, DatabaseError> {
 /// Utility für SQL-Parsing - parst mehrere SQL-Statements
 pub fn parse_sql_statements(sql: &str) -> Result<Vec<Statement>, DatabaseError> {
     let dialect = SQLiteDialect {};
-    Parser::parse_sql(&dialect, sql).map_err(|e| DatabaseError::ParseError {
+
-        reason: e.to_string(),
+    // Normalize whitespace: replace multiple whitespaces (including newlines, tabs) with single space
+    let normalized_sql = sql
+        .split_whitespace()
+        .collect::<Vec<&str>>()
+        .join(" ");
+
+    Parser::parse_sql(&dialect, &normalized_sql).map_err(|e| DatabaseError::ParseError {
+        reason: format!("Failed to parse SQL: {}", e),
         sql: sql.to_string(),
     })
 }
 
+/// Prüft ob ein Statement ein RETURNING Clause hat (AST-basiert, sicher)
+pub fn statement_has_returning(statement: &Statement) -> bool {
+    match statement {
+        Statement::Insert(insert) => insert.returning.is_some(),
+        Statement::Update { returning, .. } => returning.is_some(),
+        Statement::Delete(delete) => delete.returning.is_some(),
+        _ => false,
+    }
+}
+
 pub struct ValueConverter;
 
 impl ValueConverter {
@@ -117,11 +149,30 @@ impl ValueConverter {
     }
 }
 
+/// Execute SQL mit CRDT-Transformation (für Drizzle-Integration)
+/// Diese Funktion sollte von Drizzle verwendet werden, um CRDT-Support zu erhalten
+pub fn execute_with_crdt(
+    sql: String,
+    params: Vec<JsonValue>,
+    connection: &DbConnection,
+    hlc_service: &std::sync::MutexGuard<crate::crdt::hlc::HlcService>,
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+    with_connection(connection, |conn| {
+        let tx = conn.transaction().map_err(DatabaseError::from)?;
+        let _modified_tables = SqlExecutor::execute_internal(&tx, hlc_service, &sql, &params)?;
+        tx.commit().map_err(DatabaseError::from)?;
+
+        // Für Drizzle: gebe leeres Array zurück (wie bei execute ohne RETURNING)
+        Ok(vec![])
+    })
+}
+
+/// Execute SQL OHNE CRDT-Transformation (für spezielle Fälle)
 pub fn execute(
     sql: String,
     params: Vec<JsonValue>,
     connection: &DbConnection,
-) -> Result<usize, DatabaseError> {
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
     // Konvertiere Parameter
     let params_converted: Vec<RusqliteValue> = params
         .iter()
@@ -130,19 +181,33 @@ pub fn execute(
     let params_sql: Vec<&dyn ToSql> = params_converted.iter().map(|v| v as &dyn ToSql).collect();
 
     with_connection(connection, |conn| {
-        let affected_rows = conn.execute(&sql, &params_sql[..]).map_err(|e| {
+        if sql.to_uppercase().contains("RETURNING") {
-            // "Lazy Parsing": Extrahiere den Tabellennamen nur, wenn ein Fehler auftritt,
+            let mut stmt = conn.prepare(&sql)?;
-            // um den Overhead bei erfolgreichen Operationen zu vermeiden.
+            let num_columns = stmt.column_count();
-            let table_name = extract_primary_table_name_from_sql(&sql).unwrap_or(None);
+            let mut rows = stmt.query(&params_sql[..])?;
+            let mut result_vec: Vec<Vec<JsonValue>> = Vec::new();
 
-            DatabaseError::ExecutionError {
+            while let Some(row) = rows.next()? {
-                sql: sql.clone(),
+                let mut row_values: Vec<JsonValue> = Vec::with_capacity(num_columns);
-                reason: e.to_string(),
+                for i in 0..num_columns {
-                table: table_name,
+                    let value_ref = row.get_ref(i)?;
+                    let json_val = convert_value_ref_to_json(value_ref)?;
+                    row_values.push(json_val);
+                }
+                result_vec.push(row_values);
             }
-        })?;
+            Ok(result_vec)
-
+        } else {
-        Ok(affected_rows)
+            conn.execute(&sql, &params_sql[..]).map_err(|e| {
+                let table_name = extract_primary_table_name_from_sql(&sql).unwrap_or(None);
+                DatabaseError::ExecutionError {
+                    sql: sql.clone(),
+                    reason: e.to_string(),
+                    table: table_name,
+                }
+            })?;
+            Ok(vec![])
+        }
     })
 }
 
@@ -150,7 +215,7 @@ pub fn select(
     sql: String,
     params: Vec<JsonValue>,
     connection: &DbConnection,
-) -> Result<Vec<HashMap<String, JsonValue>>, DatabaseError> {
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
     // Validiere SQL-Statement
     let statement = parse_single_statement(&sql)?;
 
@@ -170,61 +235,36 @@ pub fn select(
     let params_sql: Vec<&dyn ToSql> = params_converted.iter().map(|v| v as &dyn ToSql).collect();
 
     with_connection(connection, |conn| {
-        let mut stmt = conn
+        let mut stmt = conn.prepare(&sql)?;
-            .prepare(&sql)
+        let num_columns = stmt.column_count();
-            .map_err(|e| DatabaseError::PrepareError {
+        let mut rows = stmt.query(&params_sql[..])?;
-                reason: e.to_string(),
+        let mut result_vec: Vec<Vec<JsonValue>> = Vec::new();
-            })?;
-
-        let column_names: Vec<String> = stmt
-            .column_names()
-            .into_iter()
-            .map(|s| s.to_string())
-            .collect();
-        let num_columns = column_names.len();
-
-        let mut rows = stmt
-            .query(&params_sql[..])
-            .map_err(|e| DatabaseError::QueryError {
-                reason: e.to_string(),
-            })?;
-
-        let mut result_vec: Vec<HashMap<String, JsonValue>> = Vec::new();
-
-        while let Some(row) = rows.next().map_err(|e| DatabaseError::RowProcessingError {
-            reason: format!("Row iteration error: {}", e),
-        })? {
-            let mut row_map: HashMap<String, JsonValue> = HashMap::with_capacity(num_columns);
 
+        while let Some(row) = rows.next()? {
+            let mut row_values: Vec<JsonValue> = Vec::with_capacity(num_columns);
             for i in 0..num_columns {
-                let col_name = &column_names[i];
+                let value_ref = row.get_ref(i)?;
-
-                /* println!(
-                    "--- Processing Column --- Index: {}, Name: '{}'",
-                    i, col_name
-                ); */
-
-                let value_ref = row
-                    .get_ref(i)
-                    .map_err(|e| DatabaseError::RowProcessingError {
-                        reason: format!("Failed to get column {} ('{}'): {}", i, col_name, e),
-                    })?;
-
                 let json_val = convert_value_ref_to_json(value_ref)?;
-
+                row_values.push(json_val);
-                //println!("Column: {} = {}", column_names[i], json_val);
-
-                row_map.insert(col_name.clone(), json_val);
             }
-            result_vec.push(row_map);
+            result_vec.push(row_values);
         }
-
         Ok(result_vec)
     })
 }
 
+pub fn select_with_crdt(
+    sql: String,
+    params: Vec<JsonValue>,
+    connection: &DbConnection,
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+    with_connection(&connection, |conn| {
+        SqlExecutor::query_select(conn, &sql, &params)
+    })
+}
+
 /// Konvertiert rusqlite ValueRef zu JSON
-fn convert_value_ref_to_json(value_ref: ValueRef) -> Result<JsonValue, DatabaseError> {
+pub fn convert_value_ref_to_json(value_ref: ValueRef) -> Result<JsonValue, DatabaseError> {
     let json_val = match value_ref {
         ValueRef::Null => JsonValue::Null,
         ValueRef::Integer(i) => JsonValue::Number(i.into()),
@@ -328,8 +368,42 @@ fn extract_tables_from_select(select: &Select, tables: &mut Vec<String>) {
             extract_tables_from_table_factor(&join.relation, tables);
         }
     }
+    if let Some(selection) = &select.selection {
+        extract_tables_from_expr_recursive(selection, tables);
+    }
 }
 
+fn extract_tables_from_expr_recursive(expr: &Expr, tables: &mut Vec<String>) {
+    match expr {
+        // This is the key: we found a subquery!
+        Expr::Subquery(subquery) => {
+            extract_tables_from_query_recursive(subquery, tables);
+        }
+        // These expressions can contain other expressions
+        Expr::BinaryOp { left, right, .. } => {
+            extract_tables_from_expr_recursive(left, tables);
+            extract_tables_from_expr_recursive(right, tables);
+        }
+        Expr::UnaryOp { expr, .. } => {
+            extract_tables_from_expr_recursive(expr, tables);
+        }
+        Expr::InSubquery { expr, subquery, .. } => {
+            extract_tables_from_expr_recursive(expr, tables);
+            extract_tables_from_query_recursive(subquery, tables);
+        }
+        Expr::Between {
+            expr, low, high, ..
+        } => {
+            extract_tables_from_expr_recursive(expr, tables);
+            extract_tables_from_expr_recursive(low, tables);
+            extract_tables_from_expr_recursive(high, tables);
+        }
+        // ... other expression types can be added here if needed
+        _ => {
+            // Other expressions (like literals, column names, etc.) don't contain tables.
+        }
+    }
+}
 /// Extrahiert Tabellennamen aus TableFactor-Strukturen
 fn extract_tables_from_table_factor(table_factor: &TableFactor, tables: &mut Vec<String>) {
     match table_factor {

src-tauri/src/database/generated.rs

@@ -16,8 +16,6 @@ pub struct HaexSettings {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub value: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub haex_tombstone: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub haex_timestamp: Option<String>,
 }
 
@@ -28,8 +26,7 @@ impl HaexSettings {
             key: row.get(1)?,
             r#type: row.get(2)?,
             value: row.get(3)?,
-            haex_tombstone: row.get(4)?,
+            haex_timestamp: row.get(4)?,
-            haex_timestamp: row.get(5)?,
         })
     }
 }
@@ -38,30 +35,21 @@ impl HaexSettings {
 #[serde(rename_all = "camelCase")]
 pub struct HaexExtensions {
     pub id: String,
+    pub public_key: String,
+    pub name: String,
+    pub version: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub author: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub entry: String,
-    pub entry: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub homepage: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub enabled: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub icon: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signature: String,
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub public_key: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub signature: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub url: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub version: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub haex_tombstone: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub haex_timestamp: Option<String>,
 }
@@ -70,19 +58,17 @@ impl HaexExtensions {
     pub fn from_row(row: &rusqlite::Row) -> rusqlite::Result<Self> {
         Ok(Self {
             id: row.get(0)?,
-            author: row.get(1)?,
+            public_key: row.get(1)?,
-            description: row.get(2)?,
+            name: row.get(2)?,
-            entry: row.get(3)?,
+            version: row.get(3)?,
-            homepage: row.get(4)?,
+            author: row.get(4)?,
-            enabled: row.get(5)?,
+            description: row.get(5)?,
-            icon: row.get(6)?,
+            entry: row.get(6)?,
-            name: row.get(7)?,
+            homepage: row.get(7)?,
-            public_key: row.get(8)?,
+            enabled: row.get(8)?,
-            signature: row.get(9)?,
+            icon: row.get(9)?,
-            url: row.get(10)?,
+            signature: row.get(10)?,
-            version: row.get(11)?,
+            haex_timestamp: row.get(11)?,
-            haex_tombstone: row.get(12)?,
-            haex_timestamp: row.get(13)?,
         })
     }
 }
@@ -91,8 +77,7 @@ impl HaexExtensions {
 #[serde(rename_all = "camelCase")]
 pub struct HaexExtensionPermissions {
     pub id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extension_id: String,
-    pub extension_id: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub resource_type: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -107,8 +92,6 @@ pub struct HaexExtensionPermissions {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub updated_at: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub haex_tombstone: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub haex_timestamp: Option<String>,
 }
 
@@ -124,8 +107,7 @@ impl HaexExtensionPermissions {
             status: row.get(6)?,
             created_at: row.get(7)?,
             updated_at: row.get(8)?,
-            haex_tombstone: row.get(9)?,
+            haex_timestamp: row.get(9)?,
-            haex_timestamp: row.get(10)?,
         })
     }
 }
@@ -208,3 +190,51 @@ impl HaexCrdtConfigs {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HaexDesktopItems {
+    pub id: String,
+    pub workspace_id: String,
+    pub item_type: String,
+    pub reference_id: String,
+    pub position_x: i64,
+    pub position_y: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub haex_timestamp: Option<String>,
+}
+
+impl HaexDesktopItems {
+    pub fn from_row(row: &rusqlite::Row) -> rusqlite::Result<Self> {
+        Ok(Self {
+            id: row.get(0)?,
+            workspace_id: row.get(1)?,
+            item_type: row.get(2)?,
+            reference_id: row.get(3)?,
+            position_x: row.get(4)?,
+            position_y: row.get(5)?,
+            haex_timestamp: row.get(6)?,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HaexWorkspaces {
+    pub id: String,
+    pub name: String,
+    pub position: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub haex_timestamp: Option<String>,
+}
+
+impl HaexWorkspaces {
+    pub fn from_row(row: &rusqlite::Row) -> rusqlite::Result<Self> {
+        Ok(Self {
+            id: row.get(0)?,
+            name: row.get(1)?,
+            position: row.get(2)?,
+            haex_timestamp: row.get(3)?,
+        })
+    }
+}
+

src-tauri/src/database/init.rs

@@ -0,0 +1,67 @@
+// src-tauri/src/database/init.rs
+// Database initialization utilities (trigger setup, etc.)
+
+use crate::crdt::trigger;
+use crate::database::error::DatabaseError;
+use crate::table_names::{
+    TABLE_DESKTOP_ITEMS,
+    TABLE_EXTENSIONS,
+    TABLE_EXTENSION_PERMISSIONS,
+    TABLE_NOTIFICATIONS,
+    TABLE_SETTINGS,
+    TABLE_WORKSPACES,
+};
+use rusqlite::{params, Connection};
+
+/// Liste aller CRDT-Tabellen die Trigger benötigen (ohne Password-Tabellen - die kommen in Extension)
+const CRDT_TABLES: &[&str] = &[
+    TABLE_SETTINGS,
+    TABLE_EXTENSIONS,
+    TABLE_EXTENSION_PERMISSIONS,
+    TABLE_NOTIFICATIONS,
+    TABLE_WORKSPACES,
+    TABLE_DESKTOP_ITEMS,
+];
+
+/// Prüft ob Trigger bereits initialisiert wurden und erstellt sie falls nötig
+///
+/// Diese Funktion wird beim ersten Öffnen einer Template-DB aufgerufen.
+/// Sie erstellt alle CRDT-Trigger für die definierten Tabellen und markiert
+/// die Initialisierung in haex_settings.
+///
+/// Bei Migrations (ALTER TABLE) werden Trigger automatisch neu erstellt,
+/// daher ist kein Versioning nötig.
+pub fn ensure_triggers_initialized(conn: &mut Connection) -> Result<bool, DatabaseError> {
+    let tx = conn.transaction()?;
+
+    // Check if triggers already initialized
+    let check_sql = format!(
+        "SELECT value FROM {} WHERE key = ? AND type = ?",
+        TABLE_SETTINGS
+    );
+    let initialized: Option<String> = tx
+        .query_row(
+            &check_sql,
+            params!["triggers_initialized", "system"],
+            |row| row.get(0),
+        )
+        .ok();
+
+    if initialized.is_some() {
+        eprintln!("DEBUG: Triggers already initialized, skipping");
+        tx.commit()?; // Wichtig: Transaktion trotzdem abschließen
+        return Ok(true); // true = war schon initialisiert
+    }
+
+    eprintln!("INFO: Initializing CRDT triggers for database...");
+
+    // Create triggers for all CRDT tables
+    for table_name in CRDT_TABLES {
+        eprintln!("  - Setting up triggers for: {}", table_name);
+        trigger::setup_triggers_for_table(&tx, table_name, false)?;
+    }
+
+    tx.commit()?;
+    eprintln!("INFO: ✓ CRDT triggers created successfully (flag pending)");
+    Ok(false) // false = wurde gerade initialisiert
+}

src-tauri/src/database/mod.rs

@@ -3,21 +3,25 @@
 pub mod core;
 pub mod error;
 pub mod generated;
+pub mod init;
 
 use crate::crdt::hlc::HlcService;
+use crate::database::core::execute_with_crdt;
 use crate::database::error::DatabaseError;
-use crate::table_names::TABLE_CRDT_CONFIGS;
+use crate::extension::database::executor::SqlExecutor;
+use crate::table_names::{TABLE_CRDT_CONFIGS, TABLE_SETTINGS};
 use crate::AppState;
 use rusqlite::Connection;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
-use std::collections::HashMap;
 use std::path::Path;
 use std::sync::Mutex;
 use std::time::UNIX_EPOCH;
 use std::{fs, sync::Arc};
 use tauri::{path::BaseDirectory, AppHandle, Manager, State};
 use tauri_plugin_fs::FsExt;
+#[cfg(not(target_os = "android"))]
+use trash;
 use ts_rs::TS;
 
 pub struct DbConnection(pub Arc<Mutex<Option<Connection>>>);
@@ -30,7 +34,7 @@ pub fn sql_select(
     sql: String,
     params: Vec<JsonValue>,
     state: State<'_, AppState>,
-) -> Result<Vec<HashMap<String, JsonValue>>, DatabaseError> {
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
     core::select(sql, params, &state.db)
 }
 
@@ -39,10 +43,50 @@ pub fn sql_execute(
     sql: String,
     params: Vec<JsonValue>,
     state: State<'_, AppState>,
-) -> Result<usize, DatabaseError> {
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
     core::execute(sql, params, &state.db)
 }
 
+#[tauri::command]
+pub fn sql_select_with_crdt(
+    sql: String,
+    params: Vec<JsonValue>,
+    state: State<'_, AppState>,
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+    core::select_with_crdt(sql, params, &state.db)
+}
+
+#[tauri::command]
+pub fn sql_execute_with_crdt(
+    sql: String,
+    params: Vec<JsonValue>,
+    state: State<'_, AppState>,
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+    let hlc_service = state.hlc.lock().map_err(|_| DatabaseError::MutexPoisoned {
+        reason: "Failed to lock HLC service".to_string(),
+    })?;
+    core::execute_with_crdt(sql, params, &state.db, &hlc_service)
+}
+
+#[tauri::command]
+pub fn sql_query_with_crdt(
+    sql: String,
+    params: Vec<JsonValue>,
+    state: State<'_, AppState>,
+) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+    let hlc_service = state.hlc.lock().map_err(|_| DatabaseError::MutexPoisoned {
+        reason: "Failed to lock HLC service".to_string(),
+    })?;
+
+    core::with_connection(&state.db, |conn| {
+        let tx = conn.transaction().map_err(DatabaseError::from)?;
+        let (_modified_tables, result) =
+            SqlExecutor::query_internal(&tx, &hlc_service, &sql, &params)?;
+        tx.commit().map_err(DatabaseError::from)?;
+        Ok(result)
+    })
+}
+
 /// Resolves a database name to the full vault path
 fn get_vault_path(app_handle: &AppHandle, vault_name: &str) -> Result<String, DatabaseError> {
     // Sicherstellen, dass der Name eine .db Endung hat
@@ -91,7 +135,6 @@ pub fn get_vaults_directory(app_handle: &AppHandle) -> Result<String, DatabaseEr
     Ok(vaults_dir.to_string_lossy().to_string())
 }
 
-//#[serde(tag = "type", content = "details")]
 #[derive(Debug, Serialize, Deserialize, TS)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
@@ -165,15 +208,70 @@ pub fn list_vaults(app_handle: AppHandle) -> Result<Vec<VaultInfo>, DatabaseErro
 
 /// Checks if a vault with the given name exists
 #[tauri::command]
-pub fn vault_exists(app_handle: AppHandle, db_name: String) -> Result<bool, DatabaseError> {
+pub fn vault_exists(app_handle: AppHandle, vault_name: String) -> Result<bool, DatabaseError> {
-    let vault_path = get_vault_path(&app_handle, &db_name)?;
+    let vault_path = get_vault_path(&app_handle, &vault_name)?;
     Ok(Path::new(&vault_path).exists())
 }
 
-/// Deletes a vault database file
+/// Moves a vault database file to trash (or deletes permanently if trash is unavailable)
 #[tauri::command]
-pub fn delete_vault(app_handle: AppHandle, db_name: String) -> Result<String, DatabaseError> {
+pub fn move_vault_to_trash(
-    let vault_path = get_vault_path(&app_handle, &db_name)?;
+    app_handle: AppHandle,
+    vault_name: String,
+) -> Result<String, DatabaseError> {
+    // On Android, trash is not available, so delete permanently
+    #[cfg(target_os = "android")]
+    {
+        println!(
+            "Android platform detected, permanently deleting vault '{}'",
+            vault_name
+        );
+        return delete_vault(app_handle, vault_name);
+    }
+
+    // On non-Android platforms, try to use trash
+    #[cfg(not(target_os = "android"))]
+    {
+        let vault_path = get_vault_path(&app_handle, &vault_name)?;
+        let vault_shm_path = format!("{}-shm", vault_path);
+        let vault_wal_path = format!("{}-wal", vault_path);
+
+        if !Path::new(&vault_path).exists() {
+            return Err(DatabaseError::IoError {
+                path: vault_path,
+                reason: "Vault does not exist".to_string(),
+            });
+        }
+
+        // Try to move to trash first (works on desktop systems)
+        let moved_to_trash = trash::delete(&vault_path).is_ok();
+
+        if moved_to_trash {
+            // Also try to move auxiliary files to trash (ignore errors as they might not exist)
+            let _ = trash::delete(&vault_shm_path);
+            let _ = trash::delete(&vault_wal_path);
+
+            Ok(format!(
+                "Vault '{}' successfully moved to trash",
+                vault_name
+            ))
+        } else {
+            // Fallback: Permanent deletion if trash fails
+            println!(
+                "Trash not available, falling back to permanent deletion for vault '{}'",
+                vault_name
+            );
+            delete_vault(app_handle, vault_name)
+        }
+    }
+}
+
+/// Deletes a vault database file permanently (bypasses trash)
+#[tauri::command]
+pub fn delete_vault(app_handle: AppHandle, vault_name: String) -> Result<String, DatabaseError> {
+    let vault_path = get_vault_path(&app_handle, &vault_name)?;
+    let vault_shm_path = format!("{}-shm", vault_path);
+    let vault_wal_path = format!("{}-wal", vault_path);
 
     if !Path::new(&vault_path).exists() {
         return Err(DatabaseError::IoError {
@@ -182,12 +280,26 @@ pub fn delete_vault(app_handle: AppHandle, db_name: String) -> Result<String, Da
         });
     }
 
+    if Path::new(&vault_shm_path).exists() {
+        fs::remove_file(&vault_shm_path).map_err(|e| DatabaseError::IoError {
+            path: vault_shm_path.clone(),
+            reason: format!("Failed to delete vault: {}", e),
+        })?;
+    }
+
+    if Path::new(&vault_wal_path).exists() {
+        fs::remove_file(&vault_wal_path).map_err(|e| DatabaseError::IoError {
+            path: vault_wal_path.clone(),
+            reason: format!("Failed to delete vault: {}", e),
+        })?;
+    }
+
     fs::remove_file(&vault_path).map_err(|e| DatabaseError::IoError {
         path: vault_path.clone(),
         reason: format!("Failed to delete vault: {}", e),
     })?;
 
-    Ok(format!("Vault '{}' successfully deleted", db_name))
+    Ok(format!("Vault '{}' successfully deleted", vault_name))
 }
 
 #[tauri::command]
@@ -337,9 +449,6 @@ pub fn open_encrypted_database(
     state: State<'_, AppState>,
 ) -> Result<String, DatabaseError> {
     println!("Opening encrypted database vault_path: {}", vault_path);
-
-    // Vault-Pfad aus dem Namen ableiten
-    //let vault_path = get_vault_path(&app_handle, &vault_name)?;
     println!("Resolved vault path: {}", vault_path);
 
     if !Path::new(&vault_path).exists() {
@@ -362,9 +471,12 @@ fn initialize_session(
     state: &State<'_, AppState>,
 ) -> Result<(), DatabaseError> {
     // 1. Establish the raw database connection
-    let conn = core::open_and_init_db(path, key, false)?;
+    let mut conn = core::open_and_init_db(path, key, false)?;
 
-    // 2. Initialize the HLC service
+    // 2. Ensure CRDT triggers are initialized (for template DB)
+    let triggers_were_already_initialized = init::ensure_triggers_initialized(&mut conn)?;
+
+    // 3. Initialize the HLC service
     let hlc_service = HlcService::try_initialize(&conn, app_handle).map_err(|e| {
         // We convert the HlcError into a DatabaseError
         DatabaseError::ExecutionError {
@@ -374,16 +486,53 @@ fn initialize_session(
         }
     })?;
 
-    // 3. Store everything in the global AppState
+    // 4. Store everything in the global AppState
     let mut db_guard = state.db.0.lock().map_err(|e| DatabaseError::LockError {
         reason: e.to_string(),
     })?;
+    // Wichtig: Wir brauchen den db_guard gleich nicht mehr,
+    // da 'execute_with_crdt' 'with_connection' aufruft, was
+    // 'state.db' selbst locken muss.
+    // Wir müssen den Guard freigeben, *bevor* wir 'execute_with_crdt' rufen,
+    // um einen Deadlock zu verhindern.
+    // Aber wir müssen die 'conn' erst hineinbewegen.
     *db_guard = Some(conn);
+    drop(db_guard);
 
     let mut hlc_guard = state.hlc.lock().map_err(|e| DatabaseError::LockError {
         reason: e.to_string(),
     })?;
     *hlc_guard = hlc_service;
 
+    // WICHTIG: hlc_guard *nicht* freigeben, da 'execute_with_crdt'
+    // eine Referenz auf die Guard erwartet.
+
+    // 5. NEUER SCHRITT: Setze das Flag via CRDT, falls nötig
+    if !triggers_were_already_initialized {
+        eprintln!("INFO: Setting 'triggers_initialized' flag via CRDT...");
+
+        let insert_sql = format!(
+            "INSERT INTO {} (id, key, type, value) VALUES (?, ?, ?, ?)",
+            TABLE_SETTINGS
+        );
+
+        // execute_with_crdt erwartet Vec<JsonValue>, kein params!-Makro
+        let params_vec: Vec<JsonValue> = vec![
+            JsonValue::String(uuid::Uuid::new_v4().to_string()),
+            JsonValue::String("triggers_initialized".to_string()),
+            JsonValue::String("system".to_string()),
+            JsonValue::String("1".to_string()),
+        ];
+
+        // Jetzt können wir 'execute_with_crdt' sicher aufrufen,
+        // da der AppState initialisiert ist.
+        execute_with_crdt(
+            insert_sql, params_vec, &state.db,  // Das &DbConnection (der Mutex)
+            &hlc_guard, // Die gehaltene MutexGuard
+        )?;
+
+        eprintln!("INFO: ✓ 'triggers_initialized' flag set.");
+    }
+
     Ok(())
 }

src-tauri/src/extension/core/manager.rs

@@ -1,14 +1,19 @@
-// src-tauri/src/extension/core/manager.rs
+use crate::database::core::with_connection;
-
+use crate::database::error::DatabaseError;
 use crate::extension::core::manifest::{EditablePermissions, ExtensionManifest, ExtensionPreview};
 use crate::extension::core::types::{copy_directory, Extension, ExtensionSource};
+use crate::extension::core::ExtensionPermissions;
 use crate::extension::crypto::ExtensionCrypto;
+use crate::extension::database::executor::SqlExecutor;
 use crate::extension::error::ExtensionError;
 use crate::extension::permissions::manager::PermissionManager;
-use crate::extension::permissions::types::{ExtensionPermission, PermissionStatus};
+use crate::extension::permissions::types::ExtensionPermission;
+use crate::table_names::{TABLE_EXTENSIONS, TABLE_EXTENSION_PERMISSIONS};
 use crate::AppState;
-use std::collections::HashMap;
+use serde_json::Value as JsonValue;
-use std::fs::File;
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::io::Cursor;
 use std::path::PathBuf;
 use std::sync::Mutex;
 use std::time::{Duration, SystemTime};
@@ -22,11 +27,38 @@ pub struct CachedPermission {
     pub ttl: Duration,
 }
 
+#[derive(Debug, Clone)]
+pub struct MissingExtension {
+    pub id: String,
+    pub public_key: String,
+    pub name: String,
+    pub version: String,
+}
+
+struct ExtensionDataFromDb {
+    id: String,
+    manifest: ExtensionManifest,
+    enabled: bool,
+}
+
 #[derive(Default)]
 pub struct ExtensionManager {
     pub production_extensions: Mutex<HashMap<String, Extension>>,
     pub dev_extensions: Mutex<HashMap<String, Extension>>,
     pub permission_cache: Mutex<HashMap<String, CachedPermission>>,
+    pub missing_extensions: Mutex<Vec<MissingExtension>>,
+}
+
+struct ExtractedExtension {
+    temp_dir: PathBuf,
+    manifest: ExtensionManifest,
+    content_hash: String,
+}
+
+impl Drop for ExtractedExtension {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(&self.temp_dir).ok();
+    }
 }
 
 impl ExtensionManager {
@@ -34,6 +66,195 @@ impl ExtensionManager {
         Self::default()
     }
 
+    /// Helper function to validate path and check for path traversal
+    /// Returns the cleaned path if valid, or None if invalid/not found
+    /// If require_exists is true, returns None if path doesn't exist
+    pub fn validate_path_in_directory(
+        base_dir: &PathBuf,
+        relative_path: &str,
+        require_exists: bool,
+    ) -> Result<Option<PathBuf>, ExtensionError> {
+        // Check for path traversal patterns
+        if relative_path.contains("..") {
+            return Err(ExtensionError::SecurityViolation {
+                reason: format!("Path traversal attempt: {}", relative_path),
+            });
+        }
+
+        // Clean the path (same logic as in protocol.rs)
+        let clean_path = relative_path
+            .replace('\\', "/")
+            .trim_start_matches('/')
+            .split('/')
+            .filter(|&part| !part.is_empty() && part != "." && part != "..")
+            .collect::<PathBuf>();
+
+        let full_path = base_dir.join(&clean_path);
+
+        // Check if file/directory exists (if required)
+        if require_exists && !full_path.exists() {
+            return Ok(None);
+        }
+
+        // Verify path is within base directory
+        let canonical_base = base_dir
+            .canonicalize()
+            .map_err(|e| ExtensionError::Filesystem { source: e })?;
+
+        if let Ok(canonical_path) = full_path.canonicalize() {
+            if !canonical_path.starts_with(&canonical_base) {
+                return Err(ExtensionError::SecurityViolation {
+                    reason: format!("Path outside base directory: {}", relative_path),
+                });
+            }
+            Ok(Some(canonical_path))
+        } else {
+            // Path doesn't exist yet - still validate it would be within base
+            if full_path.starts_with(&canonical_base) {
+                Ok(Some(full_path))
+            } else {
+                Err(ExtensionError::SecurityViolation {
+                    reason: format!("Path outside base directory: {}", relative_path),
+                })
+            }
+        }
+    }
+
+    /// Validates icon path and falls back to favicon.ico if not specified
+    fn validate_and_resolve_icon_path(
+        extension_dir: &PathBuf,
+        haextension_dir: &str,
+        icon_path: Option<&str>,
+    ) -> Result<Option<String>, ExtensionError> {
+        // If icon is specified in manifest, validate it
+        if let Some(icon) = icon_path {
+            if let Some(clean_path) = Self::validate_path_in_directory(extension_dir, icon, true)? {
+                return Ok(Some(clean_path.to_string_lossy().to_string()));
+            } else {
+                eprintln!("WARNING: Icon path specified in manifest not found: {}", icon);
+                // Continue to fallback logic
+            }
+        }
+
+        // Fallback 1: Check haextension/favicon.ico
+        let haextension_favicon = format!("{}/favicon.ico", haextension_dir);
+        if let Some(clean_path) = Self::validate_path_in_directory(extension_dir, &haextension_favicon, true)? {
+            return Ok(Some(clean_path.to_string_lossy().to_string()));
+        }
+
+        // Fallback 2: Check public/favicon.ico
+        if let Some(clean_path) = Self::validate_path_in_directory(extension_dir, "public/favicon.ico", true)? {
+            return Ok(Some(clean_path.to_string_lossy().to_string()));
+        }
+
+        // No icon found
+        Ok(None)
+    }
+
+    /// Extrahiert eine Extension-ZIP-Datei und validiert das Manifest
+    fn extract_and_validate_extension(
+        bytes: Vec<u8>,
+        temp_prefix: &str,
+        app_handle: &AppHandle,
+    ) -> Result<ExtractedExtension, ExtensionError> {
+        // Use app_cache_dir for better Android compatibility
+        let cache_dir = app_handle
+            .path()
+            .app_cache_dir()
+            .map_err(|e| ExtensionError::InstallationFailed {
+                reason: format!("Cannot get app cache dir: {}", e),
+            })?;
+
+        let temp_id = uuid::Uuid::new_v4();
+        let temp = cache_dir.join(format!("{}_{}", temp_prefix, temp_id));
+        let zip_file_path = cache_dir.join(format!("{}_{}_{}.haextension", temp_prefix, temp_id, "temp"));
+
+        // Write bytes to a temporary ZIP file first (important for Android file system)
+        fs::write(&zip_file_path, &bytes).map_err(|e| {
+            ExtensionError::filesystem_with_path(zip_file_path.display().to_string(), e)
+        })?;
+
+        // Create extraction directory
+        fs::create_dir_all(&temp)
+            .map_err(|e| ExtensionError::filesystem_with_path(temp.display().to_string(), e))?;
+
+        // Open ZIP file from disk (more reliable on Android than from memory)
+        let zip_file = fs::File::open(&zip_file_path).map_err(|e| {
+            ExtensionError::filesystem_with_path(zip_file_path.display().to_string(), e)
+        })?;
+
+        let mut archive = ZipArchive::new(zip_file).map_err(|e| {
+            ExtensionError::InstallationFailed {
+                reason: format!("Invalid ZIP: {}", e),
+            }
+        })?;
+
+        archive
+            .extract(&temp)
+            .map_err(|e| ExtensionError::InstallationFailed {
+                reason: format!("Cannot extract ZIP: {}", e),
+            })?;
+
+        // Clean up temporary ZIP file
+        let _ = fs::remove_file(&zip_file_path);
+
+        // Read haextension_dir from config if it exists, otherwise use default
+        let config_path = temp.join("haextension.config.json");
+        let haextension_dir = if config_path.exists() {
+            let config_content = std::fs::read_to_string(&config_path)
+                .map_err(|e| ExtensionError::ManifestError {
+                    reason: format!("Cannot read haextension.config.json: {}", e),
+                })?;
+
+            let config: serde_json::Value = serde_json::from_str(&config_content)
+                .map_err(|e| ExtensionError::ManifestError {
+                    reason: format!("Invalid haextension.config.json: {}", e),
+                })?;
+
+            let dir = config
+                .get("dev")
+                .and_then(|dev| dev.get("haextension_dir"))
+                .and_then(|dir| dir.as_str())
+                .unwrap_or("haextension")
+                .to_string();
+
+            dir
+        } else {
+            "haextension".to_string()
+        };
+
+        // Validate manifest path using helper function
+        let manifest_relative_path = format!("{}/manifest.json", haextension_dir);
+        let manifest_path = Self::validate_path_in_directory(&temp, &manifest_relative_path, true)?
+            .ok_or_else(|| ExtensionError::ManifestError {
+                reason: format!("manifest.json not found at {}/manifest.json", haextension_dir),
+            })?;
+
+        let actual_dir = temp.clone();
+        let manifest_content =
+            std::fs::read_to_string(&manifest_path).map_err(|e| ExtensionError::ManifestError {
+                reason: format!("Cannot read manifest: {}", e),
+            })?;
+
+        let mut manifest: ExtensionManifest = serde_json::from_str(&manifest_content)?;
+
+        // Validate and resolve icon path with fallback logic
+        let validated_icon = Self::validate_and_resolve_icon_path(&actual_dir, &haextension_dir, manifest.icon.as_deref())?;
+        manifest.icon = validated_icon;
+
+        let content_hash = ExtensionCrypto::hash_directory(&actual_dir, &manifest_path).map_err(|e| {
+            ExtensionError::SignatureVerificationFailed {
+                reason: e.to_string(),
+            }
+        })?;
+
+        Ok(ExtractedExtension {
+            temp_dir: actual_dir,
+            manifest,
+            content_hash,
+        })
+    }
+
     pub fn get_base_extension_dir(
         &self,
         app_handle: &AppHandle,
@@ -45,18 +266,26 @@ impl ExtensionManager {
                 source: std::io::Error::new(std::io::ErrorKind::NotFound, e.to_string()),
             })?
             .join("extensions");
+
+        // Sicherstellen, dass das Basisverzeichnis existiert
+        if !path.exists() {
+            fs::create_dir_all(&path)
+                .map_err(|e| ExtensionError::filesystem_with_path(path.display().to_string(), e))?;
+        }
         Ok(path)
     }
 
     pub fn get_extension_dir(
         &self,
         app_handle: &AppHandle,
-        extension_id: &str,
+        public_key: &str,
+        extension_name: &str,
         extension_version: &str,
     ) -> Result<PathBuf, ExtensionError> {
         let specific_extension_dir = self
             .get_base_extension_dir(app_handle)?
-            .join(extension_id)
+            .join(public_key)
+            .join(extension_name)
             .join(extension_version);
 
         Ok(specific_extension_dir)
@@ -110,42 +339,176 @@ impl ExtensionManager {
         prod_extensions.get(extension_id).cloned()
     }
 
-    pub fn remove_extension(&self, extension_id: &str) -> Result<(), ExtensionError> {
+    /// Find extension ID by public_key and name (checks dev extensions first, then production)
+    fn find_extension_id_by_public_key_and_name(
+        &self,
+        public_key: &str,
+        name: &str,
+    ) -> Result<Option<(String, Extension)>, ExtensionError> {
+        // 1. Check dev extensions first (higher priority)
+        let dev_extensions =
+            self.dev_extensions
+                .lock()
+                .map_err(|e| ExtensionError::MutexPoisoned {
+                    reason: e.to_string(),
+                })?;
+
+        for (id, ext) in dev_extensions.iter() {
+            if ext.manifest.public_key == public_key && ext.manifest.name == name {
+                return Ok(Some((id.clone(), ext.clone())));
+            }
+        }
+
+        // 2. Check production extensions
+        let prod_extensions =
+            self.production_extensions
+                .lock()
+                .map_err(|e| ExtensionError::MutexPoisoned {
+                    reason: e.to_string(),
+                })?;
+
+        for (id, ext) in prod_extensions.iter() {
+            if ext.manifest.public_key == public_key && ext.manifest.name == name {
+                return Ok(Some((id.clone(), ext.clone())));
+            }
+        }
+
+        Ok(None)
+    }
+
+    /// Get extension by public_key and name (used by frontend)
+    pub fn get_extension_by_public_key_and_name(
+        &self,
+        public_key: &str,
+        name: &str,
+    ) -> Result<Option<Extension>, ExtensionError> {
+        Ok(self
+            .find_extension_id_by_public_key_and_name(public_key, name)?
+            .map(|(_, ext)| ext))
+    }
+
+    pub fn remove_extension(&self, public_key: &str, name: &str) -> Result<(), ExtensionError> {
+        let (id, _) = self
+            .find_extension_id_by_public_key_and_name(public_key, name)?
+            .ok_or_else(|| ExtensionError::NotFound {
+                public_key: public_key.to_string(),
+                name: name.to_string(),
+            })?;
+
+        // Remove from dev extensions first
         {
-            let mut dev_extensions = self.dev_extensions.lock().unwrap();
+            let mut dev_extensions =
-            if dev_extensions.remove(extension_id).is_some() {
+                self.dev_extensions
+                    .lock()
+                    .map_err(|e| ExtensionError::MutexPoisoned {
+                        reason: e.to_string(),
+                    })?;
+            if dev_extensions.remove(&id).is_some() {
                 return Ok(());
             }
         }
 
+        // Remove from production extensions
         {
-            let mut prod_extensions = self.production_extensions.lock().unwrap();
+            let mut prod_extensions =
-            if prod_extensions.remove(extension_id).is_some() {
+                self.production_extensions
-                return Ok(());
+                    .lock()
-            }
+                    .map_err(|e| ExtensionError::MutexPoisoned {
+                        reason: e.to_string(),
+                    })?;
+            prod_extensions.remove(&id);
         }
 
-        Err(ExtensionError::NotFound {
+        Ok(())
-            id: extension_id.to_string(),
-        })
     }
 
     pub async fn remove_extension_internal(
         &self,
         app_handle: &AppHandle,
-        extension_id: String,
+        public_key: &str,
-        extension_version: String,
+        extension_name: &str,
+        extension_version: &str,
         state: &State<'_, AppState>,
     ) -> Result<(), ExtensionError> {
-        PermissionManager::delete_permissions(state, &extension_id).await?;
+        // Get the extension from memory to get its ID
-        self.remove_extension(&extension_id)?;
+        let extension = self
+            .get_extension_by_public_key_and_name(public_key, extension_name)?
+            .ok_or_else(|| ExtensionError::NotFound {
+                public_key: public_key.to_string(),
+                name: extension_name.to_string(),
+            })?;
 
+        eprintln!("DEBUG: Removing extension with ID: {}", extension.id);
+        eprintln!(
+            "DEBUG: Extension name: {}, version: {}",
+            extension_name, extension_version
+        );
+
+        // Lösche Permissions und Extension-Eintrag in einer Transaktion
+        with_connection(&state.db, |conn| {
+            let tx = conn.transaction().map_err(DatabaseError::from)?;
+
+            let hlc_service = state.hlc.lock().map_err(|_| DatabaseError::MutexPoisoned {
+                reason: "Failed to lock HLC service".to_string(),
+            })?;
+
+            // Lösche alle Permissions mit extension_id
+            eprintln!(
+                "DEBUG: Deleting permissions for extension_id: {}",
+                extension.id
+            );
+            PermissionManager::delete_permissions_in_transaction(&tx, &hlc_service, &extension.id)?;
+
+            // Lösche Extension-Eintrag mit extension_id
+            let sql = format!("DELETE FROM {} WHERE id = ?", TABLE_EXTENSIONS);
+            eprintln!("DEBUG: Executing SQL: {} with id = {}", sql, extension.id);
+            SqlExecutor::execute_internal_typed(
+                &tx,
+                &hlc_service,
+                &sql,
+                rusqlite::params![&extension.id],
+            )?;
+
+            eprintln!("DEBUG: Committing transaction");
+            tx.commit().map_err(DatabaseError::from)
+        })?;
+
+        eprintln!("DEBUG: Transaction committed successfully");
+
+        // Entferne aus dem In-Memory-Manager
+        self.remove_extension(public_key, extension_name)?;
+
+        // Lösche nur den spezifischen Versions-Ordner: public_key/name/version
         let extension_dir =
-            self.get_extension_dir(app_handle, &extension_id, &extension_version)?;
+            self.get_extension_dir(app_handle, public_key, extension_name, extension_version)?;
 
         if extension_dir.exists() {
-            std::fs::remove_dir_all(&extension_dir)
+            std::fs::remove_dir_all(&extension_dir).map_err(|e| {
-                .map_err(|e| ExtensionError::Filesystem { source: e })?;
+                ExtensionError::filesystem_with_path(extension_dir.display().to_string(), e)
+            })?;
+
+            // Versuche, leere Parent-Ordner zu löschen
+            // 1. Extension-Name-Ordner (key_hash/name)
+            if let Some(name_dir) = extension_dir.parent() {
+                if name_dir.exists() {
+                    if let Ok(entries) = std::fs::read_dir(name_dir) {
+                        if entries.count() == 0 {
+                            let _ = std::fs::remove_dir(name_dir);
+
+                            // 2. Key-Hash-Ordner (key_hash) - nur wenn auch leer
+                            if let Some(key_hash_dir) = name_dir.parent() {
+                                if key_hash_dir.exists() {
+                                    if let Ok(entries) = std::fs::read_dir(key_hash_dir) {
+                                        if entries.count() == 0 {
+                                            let _ = std::fs::remove_dir(key_hash_dir);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         Ok(())
@@ -153,52 +516,23 @@ impl ExtensionManager {
 
     pub async fn preview_extension_internal(
         &self,
-        source_path: String,
+        app_handle: &AppHandle,
+        file_bytes: Vec<u8>,
     ) -> Result<ExtensionPreview, ExtensionError> {
-        let source = PathBuf::from(&source_path);
+        let extracted = Self::extract_and_validate_extension(file_bytes, "haexhub_preview", app_handle)?;
-
-        let temp = std::env::temp_dir().join(format!("haexhub_preview_{}", uuid::Uuid::new_v4()));
-        std::fs::create_dir_all(&temp).map_err(|e| ExtensionError::Filesystem { source: e })?;
-
-        let file = File::open(&source).map_err(|e| ExtensionError::Filesystem { source: e })?;
-        let mut archive =
-            ZipArchive::new(file).map_err(|e| ExtensionError::InstallationFailed {
-                reason: format!("Invalid ZIP: {}", e),
-            })?;
-
-        archive
-            .extract(&temp)
-            .map_err(|e| ExtensionError::InstallationFailed {
-                reason: format!("Cannot extract ZIP: {}", e),
-            })?;
-
-        let manifest_path = temp.join("manifest.json");
-        let manifest_content =
-            std::fs::read_to_string(&manifest_path).map_err(|e| ExtensionError::ManifestError {
-                reason: format!("Cannot read manifest: {}", e),
-            })?;
-
-        let manifest: ExtensionManifest = serde_json::from_str(&manifest_content)?;
-
-        let content_hash = ExtensionCrypto::hash_directory(&temp)
-            .map_err(|e| ExtensionError::SignatureVerificationFailed { reason: e })?;
 
         let is_valid_signature = ExtensionCrypto::verify_signature(
-            &manifest.public_key,
+            &extracted.manifest.public_key,
-            &content_hash,
+            &extracted.content_hash,
-            &manifest.signature,
+            &extracted.manifest.signature,
         )
         .is_ok();
 
-        let key_hash = manifest.calculate_key_hash()?;
+        let editable_permissions = extracted.manifest.to_editable_permissions();
-        let editable_permissions = manifest.to_editable_permissions();
-
-        std::fs::remove_dir_all(&temp).ok();
 
         Ok(ExtensionPreview {
-            manifest,
+            manifest: extracted.manifest.clone(),
             is_valid_signature,
-            key_hash,
             editable_permissions,
         })
     }
@@ -206,106 +540,338 @@ impl ExtensionManager {
     pub async fn install_extension_with_permissions_internal(
         &self,
         app_handle: AppHandle,
-        source_path: String,
+        file_bytes: Vec<u8>,
         custom_permissions: EditablePermissions,
         state: &State<'_, AppState>,
     ) -> Result<String, ExtensionError> {
-        let source = PathBuf::from(&source_path);
+        let extracted = Self::extract_and_validate_extension(file_bytes, "haexhub_ext", &app_handle)?;
 
-        let temp = std::env::temp_dir().join(format!("haexhub_ext_{}", uuid::Uuid::new_v4()));
+        // Signatur verifizieren (bei Installation wird ein Fehler geworfen, nicht nur geprüft)
-        std::fs::create_dir_all(&temp).map_err(|e| ExtensionError::Filesystem { source: e })?;
+        ExtensionCrypto::verify_signature(
+            &extracted.manifest.public_key,
+            &extracted.content_hash,
+            &extracted.manifest.signature,
+        )
+        .map_err(|e| ExtensionError::SignatureVerificationFailed { reason: e })?;
 
-        let file = File::open(&source).map_err(|e| ExtensionError::Filesystem { source: e })?;
+        let extensions_dir = self.get_extension_dir(
-        let mut archive =
+            &app_handle,
-            ZipArchive::new(file).map_err(|e| ExtensionError::InstallationFailed {
+            &extracted.manifest.public_key,
-                reason: format!("Invalid ZIP: {}", e),
+            &extracted.manifest.name,
-            })?;
+            &extracted.manifest.version,
-
-        archive
-            .extract(&temp)
-            .map_err(|e| ExtensionError::InstallationFailed {
-                reason: format!("Cannot extract ZIP: {}", e),
-            })?;
-
-        let manifest_path = temp.join("manifest.json");
-        let manifest_content =
-            std::fs::read_to_string(&manifest_path).map_err(|e| ExtensionError::ManifestError {
-                reason: format!("Cannot read manifest: {}", e),
-            })?;
-
-        let manifest: ExtensionManifest = serde_json::from_str(&manifest_content)?;
-
-        let content_hash = ExtensionCrypto::hash_directory(&temp)
-            .map_err(|e| ExtensionError::SignatureVerificationFailed { reason: e })?;
-
-        ExtensionCrypto::verify_signature(&manifest.public_key, &content_hash, &manifest.signature)
-            .map_err(|e| ExtensionError::SignatureVerificationFailed { reason: e })?;
-
-        let key_hash = manifest.calculate_key_hash()?;
-        let full_extension_id = format!("{}-{}", key_hash, manifest.id);
-
-        let extensions_dir = app_handle
-            .path()
-            .app_data_dir()
-            .map_err(|e| ExtensionError::Filesystem {
-                source: std::io::Error::new(std::io::ErrorKind::NotFound, e.to_string()),
-            })?
-            .join("extensions")
-            .join(&full_extension_id)
-            .join(&manifest.version);
-
-        std::fs::create_dir_all(&extensions_dir)
-            .map_err(|e| ExtensionError::Filesystem { source: e })?;
-
-        copy_directory(
-            temp.to_string_lossy().to_string(),
-            extensions_dir.to_string_lossy().to_string(),
         )?;
 
-        std::fs::remove_dir_all(&temp).ok();
+        // If extension version already exists, remove it completely before installing
+        if extensions_dir.exists() {
+            eprintln!(
+                "Extension version already exists at {}, removing old version",
+                extensions_dir.display()
+            );
+            std::fs::remove_dir_all(&extensions_dir).map_err(|e| {
+                ExtensionError::filesystem_with_path(extensions_dir.display().to_string(), e)
+            })?;
+        }
 
-        let permissions = custom_permissions.to_internal_permissions(&full_extension_id);
+        std::fs::create_dir_all(&extensions_dir).map_err(|e| {
+            ExtensionError::filesystem_with_path(extensions_dir.display().to_string(), e)
+        })?;
 
-        let granted_permissions: Vec<_> = permissions
+        // Copy contents of extracted.temp_dir to extensions_dir
-            .into_iter()
+        // Note: extracted.temp_dir already points to the correct directory with manifest.json
-            .filter(|p| p.status == PermissionStatus::Granted)
+        for entry in fs::read_dir(&extracted.temp_dir).map_err(|e| {
-            .collect();
+            ExtensionError::filesystem_with_path(extracted.temp_dir.display().to_string(), e)
+        })? {
+            let entry = entry.map_err(|e| ExtensionError::Filesystem { source: e })?;
+            let path = entry.path();
+            let file_name = entry.file_name();
+            let dest_path = extensions_dir.join(&file_name);
 
-        PermissionManager::save_permissions(state, &full_extension_id, &granted_permissions)
+            if path.is_dir() {
-            .await?;
+                copy_directory(
+                    path.to_string_lossy().to_string(),
+                    dest_path.to_string_lossy().to_string(),
+                )?;
+            } else {
+                fs::copy(&path, &dest_path).map_err(|e| {
+                    ExtensionError::filesystem_with_path(path.display().to_string(), e)
+                })?;
+            }
+        }
+
+        // Generate UUID for extension (Drizzle's $defaultFn only works from JS, not raw SQL)
+        let extension_id = uuid::Uuid::new_v4().to_string();
+        let permissions = custom_permissions.to_internal_permissions(&extension_id);
+
+        // Extension-Eintrag und Permissions in einer Transaktion speichern
+        let actual_extension_id = with_connection(&state.db, |conn| {
+            let tx = conn.transaction().map_err(DatabaseError::from)?;
+
+            let hlc_service_guard = state.hlc.lock().map_err(|_| DatabaseError::MutexPoisoned {
+                reason: "Failed to lock HLC service".to_string(),
+            })?;
+            // Klonen, um den MutexGuard freizugeben, bevor potenziell lange DB-Operationen stattfinden
+            let hlc_service = hlc_service_guard.clone();
+            drop(hlc_service_guard);
+
+            // 1. Extension-Eintrag erstellen mit generierter UUID
+            let insert_ext_sql = format!(
+                "INSERT INTO {} (id, name, version, author, entry, icon, public_key, signature, homepage, description, enabled, single_instance) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                TABLE_EXTENSIONS
+            );
+
+            SqlExecutor::execute_internal_typed(
+                    &tx,
+                    &hlc_service,
+                    &insert_ext_sql,
+                    rusqlite::params![
+                        extension_id,
+                        extracted.manifest.name,
+                        extracted.manifest.version,
+                        extracted.manifest.author,
+                        extracted.manifest.entry,
+                        extracted.manifest.icon,
+                        extracted.manifest.public_key,
+                        extracted.manifest.signature,
+                        extracted.manifest.homepage,
+                        extracted.manifest.description,
+                        true, // enabled
+                        extracted.manifest.single_instance.unwrap_or(false),
+                    ],
+                )?;
+
+            // 2. Permissions speichern
+            let insert_perm_sql = format!(
+                "INSERT INTO {} (id, extension_id, resource_type, action, target, constraints, status) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                TABLE_EXTENSION_PERMISSIONS
+            );
+
+            for perm in &permissions {
+                use crate::database::generated::HaexExtensionPermissions;
+                let db_perm: HaexExtensionPermissions = perm.into();
+
+                SqlExecutor::execute_internal_typed(
+                    &tx,
+                    &hlc_service,
+                    &insert_perm_sql,
+                    rusqlite::params![
+                        db_perm.id,
+                        db_perm.extension_id,
+                        db_perm.resource_type,
+                        db_perm.action,
+                        db_perm.target,
+                        db_perm.constraints,
+                        db_perm.status,
+                    ],
+                )?;
+            }
+
+            tx.commit().map_err(DatabaseError::from)?;
+            Ok(extension_id.clone())
+        })?;
 
         let extension = Extension {
-            id: full_extension_id.clone(),
+            id: extension_id.clone(),
-            name: manifest.name.clone(),
             source: ExtensionSource::Production {
                 path: extensions_dir.clone(),
-                version: manifest.version.clone(),
+                version: extracted.manifest.version.clone(),
             },
-            manifest: manifest.clone(),
+            manifest: extracted.manifest.clone(),
             enabled: true,
             last_accessed: SystemTime::now(),
         };
 
         self.add_production_extension(extension)?;
 
-        Ok(full_extension_id)
+        Ok(actual_extension_id) // Gebe die actual_extension_id an den Caller zurück
-    }
-}
-
-// Backward compatibility
-#[derive(Default)]
-pub struct ExtensionState {
-    pub extensions: Mutex<HashMap<String, ExtensionManifest>>,
-}
-
-impl ExtensionState {
-    pub fn add_extension(&self, path: String, manifest: ExtensionManifest) {
-        let mut extensions = self.extensions.lock().unwrap();
-        extensions.insert(path, manifest);
     }
 
-    pub fn get_extension(&self, addon_id: &str) -> Option<ExtensionManifest> {
+    /// Scannt das Dateisystem beim Start und lädt alle installierten Erweiterungen.
-        let extensions = self.extensions.lock().unwrap();
+    pub async fn load_installed_extensions(
-        extensions.values().find(|p| p.name == addon_id).cloned()
+        &self,
+        app_handle: &AppHandle,
+        state: &State<'_, AppState>,
+    ) -> Result<Vec<String>, ExtensionError> {
+        // Clear existing data
+        self.production_extensions
+            .lock()
+            .map_err(|e| ExtensionError::MutexPoisoned {
+                reason: e.to_string(),
+            })?
+            .clear();
+        self.permission_cache
+            .lock()
+            .map_err(|e| ExtensionError::MutexPoisoned {
+                reason: e.to_string(),
+            })?
+            .clear();
+        self.missing_extensions
+            .lock()
+            .map_err(|e| ExtensionError::MutexPoisoned {
+                reason: e.to_string(),
+            })?
+            .clear();
+
+        // Lade alle Daten aus der Datenbank
+        let extensions = with_connection(&state.db, |conn| {
+            let sql = format!(
+            "SELECT id, name, version, author, entry, icon, public_key, signature, homepage, description, enabled, single_instance FROM {}",
+            TABLE_EXTENSIONS
+        );
+            eprintln!("DEBUG: SQL Query before transformation: {}", sql);
+
+            let results = SqlExecutor::query_select(conn, &sql, &[])?;
+            eprintln!("DEBUG: Query returned {} results", results.len());
+
+            let mut data = Vec::new();
+            for row in results {
+                // Wir erwarten die Werte in der Reihenfolge der SELECT-Anweisung
+                let id = row[0]
+                    .as_str()
+                    .ok_or_else(|| DatabaseError::SerializationError {
+                        reason: "Missing id field".to_string(),
+                    })?
+                    .to_string();
+
+                let manifest = ExtensionManifest {
+                    name: row[1]
+                        .as_str()
+                        .ok_or_else(|| DatabaseError::SerializationError {
+                            reason: "Missing name field".to_string(),
+                        })?
+                        .to_string(),
+                    version: row[2]
+                        .as_str()
+                        .ok_or_else(|| DatabaseError::SerializationError {
+                            reason: "Missing version field".to_string(),
+                        })?
+                        .to_string(),
+                    author: row[3].as_str().map(String::from),
+                    entry: row[4].as_str().map(String::from),
+                    icon: row[5].as_str().map(String::from),
+                    public_key: row[6].as_str().unwrap_or("").to_string(),
+                    signature: row[7].as_str().unwrap_or("").to_string(),
+                    permissions: ExtensionPermissions::default(),
+                    homepage: row[8].as_str().map(String::from),
+                    description: row[9].as_str().map(String::from),
+                    single_instance: row[11]
+                        .as_bool()
+                        .or_else(|| row[11].as_i64().map(|v| v != 0)),
+                };
+
+                let enabled = row[10]
+                    .as_bool()
+                    .or_else(|| row[10].as_i64().map(|v| v != 0))
+                    .unwrap_or(false);
+
+                data.push(ExtensionDataFromDb {
+                    id,
+                    manifest,
+                    enabled,
+                });
+            }
+            Ok(data)
+        })?;
+
+        // Schritt 2: Die gesammelten Daten verarbeiten (Dateisystem, State-Mutationen).
+        let mut loaded_extension_ids = Vec::new();
+
+        eprintln!("DEBUG: Found {} extensions in database", extensions.len());
+
+        for extension_data in extensions {
+            let extension_id = extension_data.id;
+            eprintln!("DEBUG: Processing extension: {}", extension_id);
+
+            // Use public_key/name/version path structure
+            let extension_path = self.get_extension_dir(
+                app_handle,
+                &extension_data.manifest.public_key,
+                &extension_data.manifest.name,
+                &extension_data.manifest.version,
+            )?;
+
+            // Check if extension directory exists
+            if !extension_path.exists() {
+                eprintln!(
+                    "DEBUG: Extension directory missing for: {} at {:?}",
+                    extension_id, extension_path
+                );
+                self.missing_extensions
+                    .lock()
+                    .map_err(|e| ExtensionError::MutexPoisoned {
+                        reason: e.to_string(),
+                    })?
+                    .push(MissingExtension {
+                        id: extension_id.clone(),
+                        public_key: extension_data.manifest.public_key.clone(),
+                        name: extension_data.manifest.name.clone(),
+                        version: extension_data.manifest.version.clone(),
+                    });
+                continue;
+            }
+
+            // Read haextension_dir from config if it exists, otherwise use default
+            let config_path = extension_path.join("haextension.config.json");
+            let haextension_dir = if config_path.exists() {
+                match std::fs::read_to_string(&config_path) {
+                    Ok(config_content) => {
+                        match serde_json::from_str::<serde_json::Value>(&config_content) {
+                            Ok(config) => {
+                                config
+                                    .get("dev")
+                                    .and_then(|dev| dev.get("haextension_dir"))
+                                    .and_then(|dir| dir.as_str())
+                                    .unwrap_or("haextension")
+                                    .to_string()
+                            }
+                            Err(_) => "haextension".to_string(),
+                        }
+                    }
+                    Err(_) => "haextension".to_string(),
+                }
+            } else {
+                "haextension".to_string()
+            };
+
+            // Validate manifest.json path using helper function
+            let manifest_relative_path = format!("{}/manifest.json", haextension_dir);
+            if Self::validate_path_in_directory(&extension_path, &manifest_relative_path, true)?
+                .is_none()
+            {
+                eprintln!(
+                    "DEBUG: manifest.json missing or invalid for: {} at {}/manifest.json",
+                    extension_id, haextension_dir
+                );
+                self.missing_extensions
+                    .lock()
+                    .map_err(|e| ExtensionError::MutexPoisoned {
+                        reason: e.to_string(),
+                    })?
+                    .push(MissingExtension {
+                        id: extension_id.clone(),
+                        public_key: extension_data.manifest.public_key.clone(),
+                        name: extension_data.manifest.name.clone(),
+                        version: extension_data.manifest.version.clone(),
+                    });
+                continue;
+            }
+
+            eprintln!("DEBUG: Extension loaded successfully: {}", extension_id);
+
+            let extension = Extension {
+                id: extension_id.clone(),
+                source: ExtensionSource::Production {
+                    path: extension_path,
+                    version: extension_data.manifest.version.clone(),
+                },
+                manifest: extension_data.manifest,
+                enabled: extension_data.enabled,
+                last_accessed: SystemTime::now(),
+            };
+
+            loaded_extension_ids.push(extension_id.clone());
+            self.add_production_extension(extension)?;
+        }
+
+        Ok(loaded_extension_ids)
     }
 }

src-tauri/src/extension/core/manifest.rs

@@ -1,250 +1,214 @@
-// src-tauri/src/extension/core/manifest.rs
-
-use crate::extension::crypto::ExtensionCrypto;
 use crate::extension::error::ExtensionError;
 use crate::extension::permissions::types::{
-    Action, DbConstraints, ExtensionPermission, FsConstraints, HttpConstraints,
+    Action, DbAction, ExtensionPermission, FsAction, HttpAction, PermissionConstraints,
-    PermissionConstraints, PermissionStatus, ResourceType, ShellConstraints,
+    PermissionStatus, ResourceType, ShellAction,
 };
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use ts_rs::TS;
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+/// Repräsentiert einen einzelnen Berechtigungseintrag im Manifest und im UI-Modell.
-pub struct ExtensionManifest {
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
-    pub id: String,
+#[ts(export)]
-    pub name: String,
+pub struct PermissionEntry {
-    pub version: String,
-    pub author: Option<String>,
-    pub entry: String,
-    pub icon: Option<String>,
-    pub public_key: String,
-    pub signature: String,
-    pub permissions: ExtensionManifestPermissions,
-    pub homepage: Option<String>,
-    pub description: Option<String>,
-}
-
-impl ExtensionManifest {
-    pub fn calculate_key_hash(&self) -> Result<String, ExtensionError> {
-        ExtensionCrypto::calculate_key_hash(&self.public_key)
-            .map_err(|e| ExtensionError::InvalidPublicKey { reason: e })
-    }
-
-    pub fn full_extension_id(&self) -> Result<String, ExtensionError> {
-        let key_hash = self.calculate_key_hash()?;
-        Ok(format!("{}-{}", key_hash, self.id))
-    }
-
-    pub fn to_editable_permissions(&self) -> EditablePermissions {
-        let mut permissions = Vec::new();
-
-        if let Some(db) = &self.permissions.database {
-            for resource in &db.read {
-                permissions.push(EditablePermission {
-                    resource_type: "db".to_string(),
-                    action: "read".to_string(),
-                    target: resource.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-            for resource in &db.write {
-                permissions.push(EditablePermission {
-                    resource_type: "db".to_string(),
-                    action: "write".to_string(),
-                    target: resource.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-        }
-
-        if let Some(fs) = &self.permissions.filesystem {
-            for path in &fs.read {
-                permissions.push(EditablePermission {
-                    resource_type: "fs".to_string(),
-                    action: "read".to_string(),
-                    target: path.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-            for path in &fs.write {
-                permissions.push(EditablePermission {
-                    resource_type: "fs".to_string(),
-                    action: "write".to_string(),
-                    target: path.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-        }
-
-        if let Some(http_list) = &self.permissions.http {
-            for domain in http_list {
-                permissions.push(EditablePermission {
-                    resource_type: "http".to_string(),
-                    action: "read".to_string(),
-                    target: domain.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-        }
-
-        if let Some(shell_list) = &self.permissions.shell {
-            for command in shell_list {
-                permissions.push(EditablePermission {
-                    resource_type: "shell".to_string(),
-                    action: "read".to_string(),
-                    target: command.clone(),
-                    constraints: None,
-                    status: "granted".to_string(),
-                });
-            }
-        }
-
-        EditablePermissions { permissions }
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct ExtensionManifestPermissions {
-    #[serde(default)]
-    pub database: Option<DatabaseManifestPermissions>,
-    #[serde(default)]
-    pub filesystem: Option<FilesystemManifestPermissions>,
-    #[serde(default)]
-    pub http: Option<Vec<String>>,
-    #[serde(default)]
-    pub shell: Option<Vec<String>>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct DatabaseManifestPermissions {
-    #[serde(default)]
-    pub read: Vec<String>,
-    #[serde(default)]
-    pub write: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct FilesystemManifestPermissions {
-    #[serde(default)]
-    pub read: Vec<String>,
-    #[serde(default)]
-    pub write: Vec<String>,
-}
-
-// Editable Permissions für UI
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct EditablePermissions {
-    pub permissions: Vec<EditablePermission>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct EditablePermission {
-    pub resource_type: String,
-    pub action: String,
     pub target: String,
+
+    /// Die auszuführende Aktion (z.B. "read", "read_write", "GET", "execute").
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation: Option<String>,
+
+    /// Optionale, spezifische Einschränkungen für diese Berechtigung.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[ts(type = "Record<string, unknown>")]
     pub constraints: Option<serde_json::Value>,
-    pub status: String,
+
+    /// Der Status der Berechtigung (wird nur im UI-Modell verwendet).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<PermissionStatus>,
 }
 
-impl EditablePermissions {
+#[derive(Serialize, Deserialize, TS)]
-    pub fn to_internal_permissions(&self, extension_id: &str) -> Vec<ExtensionPermission> {
+#[ts(export)]
-        self.permissions
-            .iter()
-            .map(|p| ExtensionPermission {
-                id: uuid::Uuid::new_v4().to_string(),
-                extension_id: extension_id.to_string(),
-                resource_type: match p.resource_type.as_str() {
-                    "fs" => ResourceType::Fs,
-                    "http" => ResourceType::Http,
-                    "db" => ResourceType::Db,
-                    "shell" => ResourceType::Shell,
-                    _ => ResourceType::Fs,
-                },
-                action: match p.action.as_str() {
-                    "read" => Action::Read,
-                    "write" => Action::Write,
-                    _ => Action::Read,
-                },
-                target: p.target.clone(),
-                constraints: p
-                    .constraints
-                    .as_ref()
-                    .and_then(|c| Self::parse_constraints(&p.resource_type, c)),
-                status: match p.status.as_str() {
-                    "granted" => PermissionStatus::Granted,
-                    "denied" => PermissionStatus::Denied,
-                    "ask" => PermissionStatus::Ask,
-                    _ => PermissionStatus::Denied,
-                },
-                haex_timestamp: None,
-                haex_tombstone: None,
-            })
-            .collect()
-    }
-
-    fn parse_constraints(
-        resource_type: &str,
-        json_value: &serde_json::Value,
-    ) -> Option<PermissionConstraints> {
-        match resource_type {
-            "db" => serde_json::from_value::<DbConstraints>(json_value.clone())
-                .ok()
-                .map(PermissionConstraints::Database),
-            "fs" => serde_json::from_value::<FsConstraints>(json_value.clone())
-                .ok()
-                .map(PermissionConstraints::Filesystem),
-            "http" => serde_json::from_value::<HttpConstraints>(json_value.clone())
-                .ok()
-                .map(PermissionConstraints::Http),
-            "shell" => serde_json::from_value::<ShellConstraints>(json_value.clone())
-                .ok()
-                .map(PermissionConstraints::Shell),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
 pub struct ExtensionPreview {
     pub manifest: ExtensionManifest,
     pub is_valid_signature: bool,
-    pub key_hash: String,
     pub editable_permissions: EditablePermissions,
 }
+/// Definiert die einheitliche Struktur für alle Berechtigungsarten im Manifest und UI.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
+#[ts(export)]
+pub struct ExtensionPermissions {
+    #[serde(default)]
+    pub database: Option<Vec<PermissionEntry>>,
+    #[serde(default)]
+    pub filesystem: Option<Vec<PermissionEntry>>,
+    #[serde(default)]
+    pub http: Option<Vec<PermissionEntry>>,
+    #[serde(default)]
+    pub shell: Option<Vec<PermissionEntry>>,
+}
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+/// Typ-Alias für bessere Lesbarkeit, wenn die Struktur als UI-Modell verwendet wird.
-pub struct ExtensionInfoResponse {
+pub type EditablePermissions = ExtensionPermissions;
-    pub key_hash: String,
+
+#[derive(Serialize, Deserialize, Clone, Debug, TS)]
+#[ts(export)]
+pub struct ExtensionManifest {
     pub name: String,
-    pub full_id: String,
     pub version: String,
-    pub display_name: Option<String>,
+    pub author: Option<String>,
-    pub namespace: Option<String>,
+    #[serde(default = "default_entry_value")]
-    pub allowed_origin: String,
+    pub entry: Option<String>,
+    pub icon: Option<String>,
+    pub public_key: String,
+    pub signature: String,
+    pub permissions: ExtensionPermissions,
+    pub homepage: Option<String>,
+    pub description: Option<String>,
+    #[serde(default)]
+    pub single_instance: Option<bool>,
+}
+
+fn default_entry_value() -> Option<String> {
+    Some("index.html".to_string())
+}
+
+impl ExtensionManifest {
+    /// Konvertiert die Manifest-Berechtigungen in das bearbeitbare UI-Modell,
+    /// indem der Standardstatus `Granted` gesetzt wird.
+    pub fn to_editable_permissions(&self) -> EditablePermissions {
+        let mut editable = self.permissions.clone();
+
+        let set_status_for_list = |list: Option<&mut Vec<PermissionEntry>>| {
+            if let Some(entries) = list {
+                for entry in entries.iter_mut() {
+                    entry.status = Some(PermissionStatus::Granted);
+                }
+            }
+        };
+
+        set_status_for_list(editable.database.as_mut());
+        set_status_for_list(editable.filesystem.as_mut());
+        set_status_for_list(editable.http.as_mut());
+        set_status_for_list(editable.shell.as_mut());
+
+        editable
+    }
+}
+
+impl ExtensionPermissions {
+    /// Konvertiert das UI-Modell in die flache Liste von internen `ExtensionPermission`-Objekten.
+    pub fn to_internal_permissions(&self, extension_id: &str) -> Vec<ExtensionPermission> {
+        let mut permissions = Vec::new();
+
+        if let Some(entries) = &self.database {
+            for p in entries {
+                if let Some(perm) = Self::create_internal(extension_id, ResourceType::Db, p) {
+                    permissions.push(perm);
+                }
+            }
+        }
+        if let Some(entries) = &self.filesystem {
+            for p in entries {
+                if let Some(perm) = Self::create_internal(extension_id, ResourceType::Fs, p) {
+                    permissions.push(perm);
+                }
+            }
+        }
+        if let Some(entries) = &self.http {
+            for p in entries {
+                if let Some(perm) = Self::create_internal(extension_id, ResourceType::Http, p) {
+                    permissions.push(perm);
+                }
+            }
+        }
+        if let Some(entries) = &self.shell {
+            for p in entries {
+                if let Some(perm) = Self::create_internal(extension_id, ResourceType::Shell, p) {
+                    permissions.push(perm);
+                }
+            }
+        }
+
+        permissions
+    }
+
+    /// Parst einen einzelnen `PermissionEntry` und wandelt ihn in die interne, typsichere `ExtensionPermission`-Struktur um.
+    fn create_internal(
+        extension_id: &str,
+        resource_type: ResourceType,
+        p: &PermissionEntry,
+    ) -> Option<ExtensionPermission> {
+        let operation_str = p.operation.as_deref().unwrap_or_default();
+
+        let action = match resource_type {
+            ResourceType::Db => DbAction::from_str(operation_str).ok().map(Action::Database),
+            ResourceType::Fs => FsAction::from_str(operation_str)
+                .ok()
+                .map(Action::Filesystem),
+            ResourceType::Http => HttpAction::from_str(operation_str).ok().map(Action::Http),
+            ResourceType::Shell => ShellAction::from_str(operation_str).ok().map(Action::Shell),
+        };
+
+        action.map(|act| ExtensionPermission {
+            id: uuid::Uuid::new_v4().to_string(),
+            extension_id: extension_id.to_string(),
+            resource_type: resource_type.clone(),
+            action: act,
+            target: p.target.clone(),
+            constraints: p
+                .constraints
+                .as_ref()
+                .and_then(|c| serde_json::from_value::<PermissionConstraints>(c.clone()).ok()),
+            status: p.status.clone().unwrap_or(PermissionStatus::Ask),
+            haex_timestamp: None,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, TS)]
+#[ts(export)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtensionInfoResponse {
+    pub id: String,
+    pub public_key: String,
+    pub name: String,
+    pub version: String,
+    pub author: Option<String>,
+    pub enabled: bool,
+    pub description: Option<String>,
+    pub homepage: Option<String>,
+    pub icon: Option<String>,
+    pub entry: Option<String>,
+    pub single_instance: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dev_server_url: Option<String>,
 }
 
 impl ExtensionInfoResponse {
     pub fn from_extension(
         extension: &crate::extension::core::types::Extension,
     ) -> Result<Self, ExtensionError> {
-        use crate::extension::core::types::get_tauri_origin;
+        use crate::extension::core::types::ExtensionSource;
 
-        let allowed_origin = get_tauri_origin();
+        let dev_server_url = match &extension.source {
-        let key_hash = extension.manifest.calculate_key_hash()?;
+            ExtensionSource::Development { dev_server_url, .. } => Some(dev_server_url.clone()),
-        let full_id = extension.manifest.full_extension_id()?;
+            ExtensionSource::Production { .. } => None,
+        };
 
         Ok(Self {
-            key_hash,
+            id: extension.id.clone(),
+            public_key: extension.manifest.public_key.clone(),
             name: extension.manifest.name.clone(),
-            full_id,
             version: extension.manifest.version.clone(),
-            display_name: Some(extension.manifest.name.clone()),
+            author: extension.manifest.author.clone(),
-            namespace: extension.manifest.author.clone(),
+            enabled: extension.enabled,
-            allowed_origin,
+            description: extension.manifest.description.clone(),
+            homepage: extension.manifest.homepage.clone(),
+            icon: extension.manifest.icon.clone(),
+            entry: extension.manifest.entry.clone(),
+            single_instance: extension.manifest.single_instance,
+            dev_server_url,
         })
     }
 }

src-tauri/src/extension/core/protocol.rs

@@ -1,18 +1,33 @@
 // src-tauri/src/extension/core/protocol.rs
 
+use crate::extension::core::types::get_tauri_origin;
 use crate::extension::error::ExtensionError;
 use crate::AppState;
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
 use mime;
 use serde::Deserialize;
+use serde::Serialize;
 use std::fmt;
 use std::fs;
 use std::path::PathBuf;
+use std::sync::Mutex;
+use tauri::http::Uri;
 use tauri::http::{Request, Response};
 use tauri::{AppHandle, State};
 
-#[derive(Deserialize, Debug)]
+// Extension protocol name constant
+pub const EXTENSION_PROTOCOL_NAME: &str = "haex-extension";
+
+// Cache for extension info (used for asset loading without origin header)
+lazy_static::lazy_static! {
+    static ref EXTENSION_CACHE: Mutex<Option<ExtensionInfo>> = Mutex::new(None);
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
 struct ExtensionInfo {
-    id: String,
+    public_key: String,
+    name: String,
     version: String,
 }
 
@@ -21,6 +36,7 @@ enum DataProcessingError {
     HexDecoding(hex::FromHexError),
     Utf8Conversion(std::string::FromUtf8Error),
     JsonParsing(serde_json::Error),
+    Custom(String),
 }
 
 impl fmt::Display for DataProcessingError {
@@ -31,6 +47,7 @@ impl fmt::Display for DataProcessingError {
                 write!(f, "UTF-8-Konvertierungsfehler: {}", e)
             }
             DataProcessingError::JsonParsing(e) => write!(f, "JSON-Parsing-Fehler: {}", e),
+            DataProcessingError::Custom(msg) => write!(f, "Datenverarbeitungsfehler: {}", msg),
         }
     }
 }
@@ -41,10 +58,17 @@ impl std::error::Error for DataProcessingError {
             DataProcessingError::HexDecoding(e) => Some(e),
             DataProcessingError::Utf8Conversion(e) => Some(e),
             DataProcessingError::JsonParsing(e) => Some(e),
+            DataProcessingError::Custom(_) => None,
         }
     }
 }
 
+impl From<String> for DataProcessingError {
+    fn from(msg: String) -> Self {
+        DataProcessingError::Custom(msg)
+    }
+}
+
 impl From<hex::FromHexError> for DataProcessingError {
     fn from(err: hex::FromHexError) -> Self {
         DataProcessingError::HexDecoding(err)
@@ -65,18 +89,19 @@ impl From<serde_json::Error> for DataProcessingError {
 
 pub fn resolve_secure_extension_asset_path(
     app_handle: &AppHandle,
-    state: State<AppState>,
+    state: &State<AppState>,
-    extension_id: &str,
+    public_key: &str,
+    extension_name: &str,
     extension_version: &str,
     requested_asset_path: &str,
 ) -> Result<PathBuf, ExtensionError> {
-    if extension_id.is_empty()
+    if extension_name.is_empty()
-        || !extension_id
+        || !extension_name
             .chars()
             .all(|c| c.is_ascii_alphanumeric() || c == '-')
     {
         return Err(ExtensionError::ValidationError {
-            reason: format!("Invalid extension ID: {}", extension_id),
+            reason: format!("Invalid extension name: {}", extension_name),
         });
     }
 
@@ -90,10 +115,12 @@ pub fn resolve_secure_extension_asset_path(
         });
     }
 
-    let specific_extension_dir =
+    let specific_extension_dir = state.extension_manager.get_extension_dir(
-        state
+        app_handle,
-            .extension_manager
+        public_key,
-            .get_extension_dir(app_handle, extension_id, extension_version)?;
+        extension_name,
+        extension_version,
+    )?;
 
     let clean_relative_path = requested_asset_path
         .replace('\\', "/")
@@ -148,99 +175,307 @@ pub fn extension_protocol_handler(
     app_handle: &AppHandle,
     request: &Request<Vec<u8>>,
 ) -> Result<Response<Vec<u8>>, Box<dyn std::error::Error>> {
-    let uri_ref = request.uri();
+    // Get the origin from the request
-    println!("Protokoll Handler für: {}", uri_ref);
+    let origin = request
+        .headers()
+        .get("origin")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
 
-    let host = uri_ref
+    // Only allow same-protocol requests or tauri origin
-        .host()
+    // For null/empty origin (initial load), use wildcard
-        .ok_or("Kein Host (Extension ID) in URI gefunden")?
+    let protocol_prefix = format!("{}://", EXTENSION_PROTOCOL_NAME);
-        .to_string();
+    let allowed_origin = if origin.starts_with(&protocol_prefix) || origin == get_tauri_origin() {
+        origin
+    } else if origin.is_empty() || origin == "null" {
+        "*" // Allow initial load without origin
+    } else {
+        // Reject other origins
+        return Response::builder()
+            .status(403)
+            .body(Vec::from("Origin not allowed"))
+            .map_err(|e| e.into());
+    };
+
+    // Handle OPTIONS requests for CORS preflight
+    if request.method() == "OPTIONS" {
+        return Response::builder()
+            .status(200)
+            .header("Access-Control-Allow-Origin", allowed_origin)
+            .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            .header("Access-Control-Allow-Headers", "*")
+            .header("Access-Control-Allow-Credentials", "true")
+            .body(Vec::new())
+            .map_err(|e| e.into());
+    }
+
+    let uri_ref = request.uri();
+    let referer = request
+        .headers()
+        .get("referer")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+
+    println!("Protokoll Handler für: {}", uri_ref);
+    println!("Origin: {}", origin);
+    println!("Referer: {}", referer);
 
     let path_str = uri_ref.path();
-    let segments_iter = path_str.split('/').filter(|s| !s.is_empty());
+
-    let resource_segments: Vec<&str> = segments_iter.collect();
+    // Try to decode base64-encoded extension info from URI
-    let raw_asset_path = resource_segments.join("/");
+    // Format:
+    // - Desktop: haex-extension://<base64>/{assetPath}
+    // - Android: http://localhost/{base64}/{assetPath}
+    let host = uri_ref.host().unwrap_or("");
+    println!("URI Host: {}", host);
+
+    let (info, segments_after_version) = if host == "localhost" || host == format!("{}.localhost", EXTENSION_PROTOCOL_NAME).as_str() {
+        // Android format: http://haex-extension.localhost/{base64}/{assetPath}
+        // Extract base64 from first path segment
+        println!("Android format detected: http://{}/...", host);
+        let mut segments_iter = path_str.split('/').filter(|s| !s.is_empty());
+
+        if let Some(first_segment) = segments_iter.next() {
+            println!("First path segment (base64): {}", first_segment);
+            match BASE64_STANDARD.decode(first_segment) {
+                Ok(decoded_bytes) => match String::from_utf8(decoded_bytes) {
+                    Ok(json_str) => match serde_json::from_str::<ExtensionInfo>(&json_str) {
+                        Ok(info) => {
+                            println!("=== Extension Info from path (Android) ===");
+                            println!("  PublicKey: {}", info.public_key);
+                            println!("  Name: {}", info.name);
+                            println!("  Version: {}", info.version);
+                            cache_extension_info(&info);
+
+                            // Remaining segments after base64 are the asset path
+                            let remaining: Vec<String> = segments_iter.map(|s| s.to_string()).collect();
+                            (info, remaining)
+                        }
+                        Err(e) => {
+                            eprintln!("Failed to parse JSON from base64 path: {}", e);
+                            return Response::builder()
+                                .status(400)
+                                .header("Access-Control-Allow-Origin", allowed_origin)
+                                .body(Vec::from(format!("Invalid extension info in base64 path: {}", e)))
+                                .map_err(|e| e.into());
+                        }
+                    },
+                    Err(e) => {
+                        eprintln!("Failed to decode UTF-8 from base64 path: {}", e);
+                        return Response::builder()
+                            .status(400)
+                            .header("Access-Control-Allow-Origin", allowed_origin)
+                            .body(Vec::from(format!("Invalid UTF-8 in base64 path: {}", e)))
+                            .map_err(|e| e.into());
+                    }
+                },
+                Err(e) => {
+                    eprintln!("Failed to decode base64 from path: {}", e);
+                    return Response::builder()
+                        .status(400)
+                        .header("Access-Control-Allow-Origin", allowed_origin)
+                        .body(Vec::from(format!("Invalid base64 in path: {}", e)))
+                        .map_err(|e| e.into());
+                }
+            }
+        } else {
+            eprintln!("No path segment found for Android format");
+            return Response::builder()
+                .status(400)
+                .header("Access-Control-Allow-Origin", allowed_origin)
+                .body(Vec::from("No base64 segment found in path"))
+                .map_err(|e| e.into());
+        }
+    } else if host != "localhost" && !host.is_empty() {
+        // Desktop format: haex-extension://<base64>/{assetPath}
+        println!("Desktop format detected: haex-extension://<base64>/...");
+        match BASE64_STANDARD.decode(host) {
+            Ok(decoded_bytes) => match String::from_utf8(decoded_bytes) {
+                Ok(json_str) => match serde_json::from_str::<ExtensionInfo>(&json_str) {
+                    Ok(info) => {
+                        println!("=== Extension Info from base64-encoded host ===");
+                        println!("  PublicKey: {}", info.public_key);
+                        println!("  Name: {}", info.name);
+                        println!("  Version: {}", info.version);
+                        cache_extension_info(&info);
+
+                        // Parse path segments as asset path
+                        // Format: haex-extension://<base64>/{asset_path}
+                        // All extension info is in the base64-encoded host
+                        let segments: Vec<String> = path_str
+                            .split('/')
+                            .filter(|s| !s.is_empty())
+                            .map(|s| s.to_string())
+                            .collect();
+
+                        (info, segments)
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to parse JSON from base64 host: {}", e);
+                        return Response::builder()
+                            .status(400)
+                            .header("Access-Control-Allow-Origin", allowed_origin)
+                            .body(Vec::from(format!("Invalid extension info in base64 host: {}", e)))
+                            .map_err(|e| e.into());
+                    }
+                },
+                Err(e) => {
+                    eprintln!("Failed to decode UTF-8 from base64 host: {}", e);
+                    return Response::builder()
+                        .status(400)
+                        .header("Access-Control-Allow-Origin", allowed_origin)
+                        .body(Vec::from(format!("Invalid UTF-8 in base64 host: {}", e)))
+                        .map_err(|e| e.into());
+                }
+            },
+            Err(e) => {
+                eprintln!("Failed to decode base64 host: {}", e);
+                return Response::builder()
+                    .status(400)
+                    .header("Access-Control-Allow-Origin", allowed_origin)
+                    .body(Vec::from(format!("Invalid base64 in host: {}", e)))
+                    .map_err(|e| e.into());
+            }
+        }
+    } else {
+        // No base64 host - use path-based parsing (for localhost/Android/Windows)
+        parse_extension_info_from_path(path_str, origin, uri_ref, referer, &allowed_origin)?
+    };
+
+    // Construct asset path from remaining segments
+    let raw_asset_path = segments_after_version.join("/");
+
+    // Simple asset loading: if path is empty, serve index.html, otherwise try to load the asset
+    // This is framework-agnostic and lets the file system determine if it exists
     let asset_to_load = if raw_asset_path.is_empty() {
         "index.html"
     } else {
         &raw_asset_path
     };
 
-    match process_hex_encoded_json(&host) {
+    println!("Path: {}", path_str);
-        Ok(info) => {
+    println!("Asset to load: {}", asset_to_load);
-            println!("Daten erfolgreich verarbeitet:");
-            println!("  ID: {}", info.id);
-            println!("  Version: {}", info.version);
-            let absolute_secure_path = resolve_secure_extension_asset_path(
-                app_handle,
-                state,
-                &info.id,
-                &info.version,
-                &asset_to_load,
-            )?;
 
-            println!("absolute_secure_path: {}", absolute_secure_path.display());
+    let absolute_secure_path = resolve_secure_extension_asset_path(
+        app_handle,
+        &state,
+        &info.public_key,
+        &info.name,
+        &info.version,
+        &asset_to_load,
+    )?;
 
-            if absolute_secure_path.exists() && absolute_secure_path.is_file() {
+    println!("Resolved path: {}", absolute_secure_path.display());
-                match fs::read(&absolute_secure_path) {
+    println!("File exists: {}", absolute_secure_path.exists());
-                    Ok(content) => {
-                        let mime_type = mime_guess::from_path(&absolute_secure_path)
-                            .first_or(mime::APPLICATION_OCTET_STREAM)
-                            .to_string();
-                        let content_length = content.len();
-                        println!(
-                            "Liefere {} ({}, {} bytes) ",
-                            absolute_secure_path.display(),
-                            mime_type,
-                            content_length
-                        );
-                        Response::builder()
-                            .status(200)
-                            .header("Content-Type", mime_type)
-                            .header("Content-Length", content_length.to_string())
-                            .header("Accept-Ranges", "bytes")
-                            .body(content)
-                            .map_err(|e| e.into())
-                    }
-                    Err(e) => {
-                        eprintln!(
-                            "Fehler beim Lesen der Datei {}: {}",
-                            absolute_secure_path.display(),
-                            e
-                        );
-                        let status_code = if e.kind() == std::io::ErrorKind::NotFound {
-                            404
-                        } else if e.kind() == std::io::ErrorKind::PermissionDenied {
-                            403
-                        } else {
-                            500
-                        };
 
-                        Response::builder()
+    if absolute_secure_path.exists() && absolute_secure_path.is_file() {
-                            .status(status_code)
+        match fs::read(&absolute_secure_path) {
-                            .body(Vec::new())
+            Ok(content) => {
-                            .map_err(|e| e.into())
+                let mime_type = mime_guess::from_path(&absolute_secure_path)
-                    }
+                    .first_or(mime::APPLICATION_OCTET_STREAM)
-                }
+                    .to_string();
-            } else {
+
-                eprintln!(
+                // Note: Base tag and polyfills are now injected by the SDK at runtime
-                    "Asset nicht gefunden oder ist kein File: {}",
+                // No server-side HTML modification needed
-                    absolute_secure_path.display()
+
+                let content_length = content.len();
+                println!(
+                    "Liefere {} ({}, {} bytes) ",
+                    absolute_secure_path.display(),
+                    mime_type,
+                    content_length
                 );
                 Response::builder()
-                    .status(404)
+                    .status(200)
+                    .header("Content-Type", &mime_type)
+                    .header("Content-Length", content_length.to_string())
+                    .header("Accept-Ranges", "bytes")
+                    .header("Access-Control-Allow-Origin", allowed_origin)
+                    .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+                    .header("Access-Control-Allow-Headers", "*")
+                    .header("Access-Control-Allow-Credentials", "true")
+                    .body(content)
+                    .map_err(|e| e.into())
+            }
+            Err(e) => {
+                eprintln!(
+                    "Fehler beim Lesen der Datei {}: {}",
+                    absolute_secure_path.display(),
+                    e
+                );
+                let status_code = if e.kind() == std::io::ErrorKind::NotFound {
+                    404
+                } else if e.kind() == std::io::ErrorKind::PermissionDenied {
+                    403
+                } else {
+                    500
+                };
+                Response::builder()
+                    .status(status_code)
+                    .header("Access-Control-Allow-Origin", allowed_origin)
+                    .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+                    .header("Access-Control-Allow-Headers", "*")
                     .body(Vec::new())
                     .map_err(|e| e.into())
             }
         }
-        Err(e) => {
+    } else {
-            eprintln!("Fehler bei der Datenverarbeitung: {}", e);
+        // Asset not found - try index.html fallback for SPA routing
+        // This allows client-side routing to work (e.g., /settings -> index.html)
+        if asset_to_load != "index.html" {
+            eprintln!(
+                "Asset nicht gefunden: {}, versuche index.html fallback für SPA routing",
+                absolute_secure_path.display()
+            );
 
-            Response::builder()
+            let index_path = resolve_secure_extension_asset_path(
-                .status(500)
+                app_handle,
-                .body(Vec::new())
+                &state,
-                .map_err(|e| e.into())
+                &info.public_key,
+                &info.name,
+                &info.version,
+                "index.html",
+            )?;
+
+            if index_path.exists() && index_path.is_file() {
+                match fs::read(&index_path) {
+                    Ok(content) => {
+                        let mime_type = "text/html";
+
+                        // Note: Base tag and polyfills are injected by SDK at runtime
+
+                        let content_length = content.len();
+                        return Response::builder()
+                            .status(200)
+                            .header("Content-Type", mime_type)
+                            .header("Content-Length", content_length.to_string())
+                            .header("Accept-Ranges", "bytes")
+                            .header("Access-Control-Allow-Origin", allowed_origin)
+                            .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+                            .header("Access-Control-Allow-Headers", "*")
+                            .header("Access-Control-Allow-Credentials", "true")
+                            .body(content)
+                            .map_err(|e| e.into());
+                    }
+                    Err(_) => {
+                        // Fall through to 404
+                    }
+                }
+            }
         }
+
+        // No fallback available - return 404
+        eprintln!(
+            "Asset nicht gefunden oder ist kein File: {}",
+            absolute_secure_path.display()
+        );
+        Response::builder()
+            .status(404)
+            .header("Access-Control-Allow-Origin", allowed_origin)
+            .header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            .header("Access-Control-Allow-Headers", "*")
+            .body(Vec::new())
+            .map_err(|e| e.into())
     }
 }
 
@@ -250,3 +485,195 @@ fn process_hex_encoded_json(hex_input: &str) -> Result<ExtensionInfo, DataProces
     let extension_info: ExtensionInfo = serde_json::from_str(&json_string)?;
     Ok(extension_info)
 }
+
+fn parse_encoded_info_from_origin_or_uri_or_referer_or_cache(
+    origin: &str,
+    uri_ref: &Uri,
+    referer: &str,
+) -> Result<ExtensionInfo, DataProcessingError> {
+    // Return direkt ExtensionInfo (dekodiert)
+    // 1-3. Bestehende Fallbacks (wie vorher, aber return decoded Info statt hex)
+    if !origin.is_empty() && origin != "null" {
+        if let Ok(hex) = parse_from_origin(origin) {
+            if let Ok(info) = process_hex_encoded_json(&hex) {
+                cache_extension_info(&info); // Cache setzen
+                println!("Parsed und gecached aus Origin: {}", hex);
+                return Ok(info);
+            }
+        }
+    }
+
+    println!("Fallback zu URI-Parsing");
+    if let Ok(hex) = parse_from_uri_path(uri_ref) {
+        if let Ok(info) = process_hex_encoded_json(&hex) {
+            cache_extension_info(&info); // Cache setzen
+            println!("Parsed und gecached aus URI: {}", hex);
+            return Ok(info);
+        }
+    }
+
+    println!("Fallback zu Referer-Parsing: {}", referer);
+    if !referer.is_empty() && referer != "null" {
+        if let Ok(hex) = parse_from_uri_string(referer) {
+            if let Ok(info) = process_hex_encoded_json(&hex) {
+                cache_extension_info(&info); // Cache setzen
+                println!("Parsed und gecached aus Referer: {}", hex);
+                return Ok(info);
+            }
+        }
+    }
+
+    // 4. Fallback: Globaler Cache (für Assets in derselben Session)
+    println!("Fallback zu Cache");
+    if let Some(cached_info) = get_cached_extension_info() {
+        println!(
+            "Gecached Info verwendet: PublicKey={}, Name={}, Version={}",
+            cached_info.public_key, cached_info.name, cached_info.version
+        );
+        return Ok(cached_info);
+    }
+
+    Err(
+        "Kein gültiger Hex in Origin, URI, Referer oder Cache gefunden"
+            .to_string()
+            .into(),
+    )
+}
+
+// NEU: Cache-Helper (Mutex-sicher)
+fn cache_extension_info(info: &ExtensionInfo) {
+    if let Ok(mut cache) = EXTENSION_CACHE.lock() {
+        *cache = Some(info.clone());
+    }
+}
+
+fn get_cached_extension_info() -> Option<ExtensionInfo> {
+    if let Ok(cache) = EXTENSION_CACHE.lock() {
+        cache.clone()
+    } else {
+        None
+    }
+}
+
+fn parse_hex_from_url_string(url_str: &str) -> Result<String, DataProcessingError> {
+    // Suche nach Scheme-Ende (://)
+    let scheme_end = match url_str.find("://") {
+        Some(pos) => pos + 3, // Nach "://"
+        _none => return Err("Kein Scheme in URL".to_string().into()),
+    };
+
+    let after_scheme = &url_str[scheme_end..];
+    let path_start = match after_scheme.find('/') {
+        Some(pos) => pos,
+        _none => return Err("Kein Path in URL".to_string().into()),
+    };
+
+    let path = &after_scheme[path_start..]; // z.B. "/7b22.../index.html"
+    let mut segments = path.split('/').filter(|s| !s.is_empty());
+
+    let first_segment = match segments.next() {
+        Some(seg) => seg,
+        _none => return Err("Kein Path-Segment in URL".to_string().into()),
+    };
+
+    validate_and_return_hex(first_segment)
+}
+
+// Vereinfachte parse_from_origin
+fn parse_from_origin(origin: &str) -> Result<String, DataProcessingError> {
+    parse_hex_from_url_string(origin)
+}
+
+// Vereinfachte parse_from_uri_path
+fn parse_from_uri_path(uri_ref: &Uri) -> Result<String, DataProcessingError> {
+    let uri_str = uri_ref.to_string();
+    parse_hex_from_url_string(&uri_str)
+}
+
+// Vereinfachte parse_from_uri_string (für Referer)
+fn parse_from_uri_string(uri_str: &str) -> Result<String, DataProcessingError> {
+    parse_hex_from_url_string(uri_str)
+}
+
+// validate_and_return_hex bleibt unverändert (aus letztem Vorschlag)
+fn validate_and_return_hex(segment: &str) -> Result<String, DataProcessingError> {
+    if segment.is_empty() {
+        return Err("Kein Extension-Info (hex) im Path".to_string().into());
+    }
+    if segment.len() % 2 != 0 {
+        return Err("Ungültiger Hex: Ungerade Länge".to_string().into());
+    }
+    if !segment.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err("Ungültiger Hex: Ungültige Zeichen".to_string().into());
+    }
+    Ok(segment.to_string())
+}
+
+fn encode_hex_for_log(info: &ExtensionInfo) -> String {
+    let json_str = serde_json::to_string(info).unwrap_or_default();
+    hex::encode(json_str.as_bytes())
+}
+
+// Helper function to parse extension info from path segments
+fn parse_extension_info_from_path(
+    path_str: &str,
+    origin: &str,
+    uri_ref: &Uri,
+    referer: &str,
+    allowed_origin: &str,
+) -> Result<(ExtensionInfo, Vec<String>), Box<dyn std::error::Error>> {
+    let mut segments_iter = path_str.split('/').filter(|s| !s.is_empty());
+
+    match (segments_iter.next(), segments_iter.next(), segments_iter.next()) {
+        (Some(public_key), Some(name), Some(version)) => {
+            println!("=== Extension Protocol Handler (path-based) ===");
+            println!("Full URI: {}", uri_ref);
+            println!("Parsed from path segments:");
+            println!("  PublicKey: {}", public_key);
+            println!("  Name: {}", name);
+            println!("  Version: {}", version);
+
+            let info = ExtensionInfo {
+                public_key: public_key.to_string(),
+                name: name.to_string(),
+                version: version.to_string(),
+            };
+
+            cache_extension_info(&info);
+
+            // Collect remaining segments as asset path (owned strings)
+            let remaining: Vec<String> = segments_iter.map(|s| s.to_string()).collect();
+
+            Ok((info, remaining))
+        }
+        _ => {
+            // Fallback: Try hex-encoded format for backwards compatibility
+            match parse_encoded_info_from_origin_or_uri_or_referer_or_cache(
+                origin, uri_ref, referer,
+            ) {
+                Ok(decoded) => {
+                    println!("=== Extension Protocol Handler (legacy hex format) ===");
+                    println!("Full URI: {}", uri_ref);
+                    println!("Decoded info:");
+                    println!("  PublicKey: {}", decoded.public_key);
+                    println!("  Name: {}", decoded.name);
+                    println!("  Version: {}", decoded.version);
+
+                    // For legacy format, collect all segments after parsing (owned strings)
+                    let segments: Vec<String> = path_str
+                        .split('/')
+                        .filter(|s| !s.is_empty())
+                        .skip(1) // Skip the hex segment
+                        .map(|s| s.to_string())
+                        .collect();
+
+                    Ok((decoded, segments))
+                }
+                Err(e) => {
+                    eprintln!("Fehler beim Parsen (alle Fallbacks): {}", e);
+                    Err(format!("Ungültige Anfrage: {}", e).into())
+                }
+            }
+        }
+    }
+}

src-tauri/src/extension/core/types.rs

@@ -21,11 +21,15 @@ pub enum ExtensionSource {
 /// Complete extension data structure
 #[derive(Debug, Clone)]
 pub struct Extension {
+    /// UUID from database (primary key)
     pub id: String,
-    pub name: String,
+    /// Extension source (production path or dev server)
     pub source: ExtensionSource,
+    /// Extension manifest containing all metadata (name, version, public_key, etc.)
     pub manifest: ExtensionManifest,
+    /// Whether the extension is enabled
     pub enabled: bool,
+    /// Last time the extension was accessed
     pub last_accessed: SystemTime,
 }
 
@@ -47,7 +51,9 @@ pub fn get_tauri_origin() -> String {
 
     #[cfg(target_os = "android")]
     {
-        "tauri://localhost".to_string()
+        // On Android, with http://*.localhost URLs, the origin is "null"
+        // This is a browser security feature for local/file protocols
+        "null".to_string()
     }
 
     #[cfg(target_os = "ios")]

src-tauri/src/extension/crypto.rs

@@ -1,26 +1,16 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
 // src-tauri/src/extension/crypto.rs
+use crate::extension::error::ExtensionError;
 use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 use sha2::{Digest, Sha256};
 
 pub struct ExtensionCrypto;
 
 impl ExtensionCrypto {
-    /// Berechnet Hash vom Public Key (wie im SDK)
-    pub fn calculate_key_hash(public_key_hex: &str) -> Result<String, String> {
-        let public_key_bytes =
-            hex::decode(public_key_hex).map_err(|e| format!("Invalid public key hex: {}", e))?;
-
-        let public_key = VerifyingKey::from_bytes(&public_key_bytes.try_into().unwrap())
-            .map_err(|e| format!("Invalid public key: {}", e))?;
-
-        let mut hasher = Sha256::new();
-        hasher.update(public_key.as_bytes());
-        let result = hasher.finalize();
-
-        // Ersten 20 Hex-Zeichen (10 Bytes) - wie im SDK
-        Ok(hex::encode(&result[..10]))
-    }
-
     /// Verifiziert Extension-Signatur
     pub fn verify_signature(
         public_key_hex: &str,
@@ -45,30 +35,110 @@ impl ExtensionCrypto {
     }
 
     /// Berechnet Hash eines Verzeichnisses (für Verifikation)
-    pub fn hash_directory(dir: &std::path::Path) -> Result<String, String> {
+    pub fn hash_directory(dir: &Path, manifest_path: &Path) -> Result<String, ExtensionError> {
-        use std::fs;
+        // 1. Alle Dateipfade rekursiv sammeln
+        let mut all_files = Vec::new();
+        Self::collect_files_recursively(dir, &mut all_files)
+            .map_err(|e| ExtensionError::Filesystem { source: e })?;
 
-        let mut hasher = Sha256::new();
+        // 2. Konvertiere zu relativen Pfaden für konsistente Sortierung (wie im SDK)
-        let mut entries: Vec<_> = fs::read_dir(dir)
+        let mut relative_files: Vec<(String, PathBuf)> = all_files
-            .map_err(|e| format!("Cannot read directory: {}", e))?
+            .into_iter()
-            .filter_map(|e| e.ok())
+            .map(|path| {
+                let relative = path.strip_prefix(dir)
+                    .unwrap_or(&path)
+                    .to_string_lossy()
+                    .to_string()
+                    // Normalisiere Pfad-Separatoren zu Unix-Style (/) für plattformübergreifende Konsistenz
+                    .replace('\\', "/");
+                (relative, path)
+            })
             .collect();
 
-        // Sortieren für deterministische Hashes
+        // 3. Sortiere nach relativen Pfaden
-        entries.sort_by_key(|e| e.path());
+        relative_files.sort_by(|a, b| a.0.cmp(&b.0));
 
-        for entry in entries {
+        let mut hasher = Sha256::new();
-            let path = entry.path();
+
-            if path.is_file() {
+        // Canonicalize manifest path for comparison (important on Android where symlinks may differ)
-                let content = fs::read(&path)
+        // Also ensure the canonical path is still within the allowed directory (security check)
-                    .map_err(|e| format!("Cannot read file {}: {}", path.display(), e))?;
+        let canonical_manifest_path = manifest_path.canonicalize()
+            .unwrap_or_else(|_| manifest_path.to_path_buf());
+
+        // Security: Verify canonical manifest path is still within dir
+        let canonical_dir = dir.canonicalize()
+            .unwrap_or_else(|_| dir.to_path_buf());
+
+        if !canonical_manifest_path.starts_with(&canonical_dir) {
+            return Err(ExtensionError::ManifestError {
+                reason: format!("Manifest path resolves outside of extension directory (potential path traversal)"),
+            });
+        }
+
+        // 4. Inhalte der sortierten Dateien hashen
+        for (_relative, file_path) in relative_files {
+            // Canonicalize file_path for comparison
+            let canonical_file_path = file_path.canonicalize()
+                .unwrap_or_else(|_| file_path.clone());
+
+            if canonical_file_path == canonical_manifest_path {
+                // FÜR DIE MANIFEST.JSON:
+                let content_str = fs::read_to_string(&file_path)
+                    .map_err(|e| ExtensionError::Filesystem { source: e })?;
+
+                // Parse zu einem generischen JSON-Wert
+                let mut manifest: serde_json::Value =
+                    serde_json::from_str(&content_str).map_err(|e| {
+                        ExtensionError::ManifestError {
+                            reason: format!("Cannot parse manifest JSON: {}", e),
+                        }
+                    })?;
+
+                // Entferne oder leere das Signaturfeld, um den "kanonischen Inhalt" zu erhalten
+                if let Some(obj) = manifest.as_object_mut() {
+                    obj.insert(
+                        "signature".to_string(),
+                        serde_json::Value::String("".to_string()),
+                    );
+                }
+
+                // Serialisiere das modifizierte Manifest zurück (mit 2 Spaces, wie in JS)
+                // serde_json sortiert die Keys automatisch alphabetisch
+                let canonical_manifest_content =
+                    serde_json::to_string_pretty(&manifest).map_err(|e| {
+                        ExtensionError::ManifestError {
+                            reason: format!("Failed to serialize manifest: {}", e),
+                        }
+                    })?;
+
+                // Normalisiere Zeilenenden zu Unix-Style (\n), wie Node.js JSON.stringify es macht
+                // Dies ist wichtig für plattformübergreifende Konsistenz (Desktop vs Android)
+                let normalized_content = canonical_manifest_content.replace("\r\n", "\n");
+
+                hasher.update(normalized_content.as_bytes());
+            } else {
+                // FÜR ALLE ANDEREN DATEIEN:
+                let content =
+                    fs::read(&file_path).map_err(|e| ExtensionError::Filesystem { source: e })?;
                 hasher.update(&content);
-            } else if path.is_dir() {
-                let subdir_hash = Self::hash_directory(&path)?;
-                hasher.update(hex::decode(&subdir_hash).unwrap());
             }
         }
 
         Ok(hex::encode(hasher.finalize()))
     }
+
+    fn collect_files_recursively(dir: &Path, file_list: &mut Vec<PathBuf>) -> std::io::Result<()> {
+        if dir.is_dir() {
+            for entry in fs::read_dir(dir)? {
+                let entry = entry?;
+                let path = entry.path();
+                if path.is_dir() {
+                    Self::collect_files_recursively(&path, file_list)?;
+                } else {
+                    file_list.push(path);
+                }
+            }
+        }
+        Ok(())
+    }
 }

src-tauri/src/extension/database/executor.rs

@@ -1,11 +1,11 @@
-// src-tauri/src/extension/database/executor.rs (neu)
+// src-tauri/src/extension/database/executor.rs
 
 use crate::crdt::hlc::HlcService;
 use crate::crdt::transformer::CrdtTransformer;
 use crate::crdt::trigger;
-use crate::database::core::{parse_sql_statements, ValueConverter};
+use crate::database::core::{convert_value_ref_to_json, parse_sql_statements, ValueConverter};
 use crate::database::error::DatabaseError;
-use rusqlite::{params_from_iter, Params, Transaction};
+use rusqlite::{params_from_iter, types::Value as SqliteValue, ToSql, Transaction};
 use serde_json::Value as JsonValue;
 use sqlparser::ast::Statement;
 use std::collections::HashSet;
@@ -14,27 +14,25 @@ use std::collections::HashSet;
 pub struct SqlExecutor;
 
 impl SqlExecutor {
-    pub fn execute_internal_typed<P>(
+    /// Führt ein SQL Statement OHNE RETURNING aus (mit CRDT)
+    /// Returns: modified_schema_tables
+    pub fn execute_internal_typed(
         tx: &Transaction,
         hlc_service: &HlcService,
         sql: &str,
-        params: P, // Akzeptiert jetzt alles, was rusqlite als Parameter versteht
+        params: &[&dyn ToSql],
-    ) -> Result<HashSet<String>, DatabaseError>
+    ) -> Result<HashSet<String>, DatabaseError> {
-    where
-        P: Params,
-    {
         let mut ast_vec = parse_sql_statements(sql)?;
 
-        // Wir stellen sicher, dass wir nur EIN Statement verarbeiten. Das ist sicherer.
         if ast_vec.len() != 1 {
             return Err(DatabaseError::ExecutionError {
                 sql: sql.to_string(),
-                reason: "execute_internal_typed sollte nur ein einzelnes SQL-Statement erhalten"
+                reason: "execute_internal_typed should only receive a single SQL statement"
                     .to_string(),
                 table: None,
             });
         }
-        // Wir nehmen das einzige Statement aus dem Vektor.
+
         let mut statement = ast_vec.pop().unwrap();
 
         let transformer = CrdtTransformer::new();
@@ -46,53 +44,61 @@ impl SqlExecutor {
                 })?;
 
         let mut modified_schema_tables = HashSet::new();
-        if let Some(table_name) =
+        if let Some(table_name) = transformer.transform_execute_statement_with_table_info(
-            transformer.transform_execute_statement(&mut statement, &hlc_timestamp)?
+            &mut statement,
-        {
+            &hlc_timestamp,
+        )? {
             modified_schema_tables.insert(table_name);
         }
 
-        // Führe das transformierte Statement aus.
-        // `params` wird jetzt nur noch einmal hierher bewegt, was korrekt ist.
         let sql_str = statement.to_string();
+        eprintln!("DEBUG: Transformed execute SQL: {}", sql_str);
+
+        // Führe Statement aus
         tx.execute(&sql_str, params)
             .map_err(|e| DatabaseError::ExecutionError {
                 sql: sql_str.clone(),
                 table: None,
-                reason: e.to_string(),
+                reason: format!("Execute failed: {}", e),
             })?;
 
-        // Die Trigger-Logik für CREATE TABLE bleibt erhalten.
+        // Trigger-Logik für CREATE TABLE
         if let Statement::CreateTable(create_table_details) = statement {
-            let table_name_str = create_table_details.name.to_string();
+            let raw_name = create_table_details.name.to_string();
+            // Remove quotes from table name
+            let table_name_str = raw_name
+                .trim_matches('"')
+                .trim_matches('`')
+                .to_string();
+            eprintln!("DEBUG: Setting up triggers for table: {}", table_name_str);
             trigger::setup_triggers_for_table(tx, &table_name_str, false)?;
         }
 
         Ok(modified_schema_tables)
     }
-    /// Führt SQL aus (mit CRDT-Transformation) - OHNE Permission-Check
+
-    pub fn execute_internal(
+    /// Führt ein SQL Statement MIT RETURNING aus (mit CRDT)
+    /// Returns: (modified_schema_tables, returning_results)
+    pub fn query_internal_typed(
         tx: &Transaction,
         hlc_service: &HlcService,
         sql: &str,
-        params: &[JsonValue],
+        params: &[&dyn ToSql],
-    ) -> Result<HashSet<String>, DatabaseError> {
+    ) -> Result<(HashSet<String>, Vec<Vec<JsonValue>>), DatabaseError> {
-        // Parameter validation
+        let mut ast_vec = parse_sql_statements(sql)?;
-        let total_placeholders = sql.matches('?').count();
+
-        if total_placeholders != params.len() {
+        if ast_vec.len() != 1 {
-            return Err(DatabaseError::ParameterMismatchError {
+            return Err(DatabaseError::ExecutionError {
-                expected: total_placeholders,
-                provided: params.len(),
                 sql: sql.to_string(),
+                reason: "query_internal_typed should only receive a single SQL statement"
+                    .to_string(),
+                table: None,
             });
         }
 
-        // SQL parsing
+        let mut statement = ast_vec.pop().unwrap();
-        let mut ast_vec = parse_sql_statements(sql)?;
 
         let transformer = CrdtTransformer::new();
-
-        // Generate HLC timestamp
         let hlc_timestamp =
             hlc_service
                 .new_timestamp_and_persist(tx)
@@ -100,110 +106,179 @@ impl SqlExecutor {
                     reason: e.to_string(),
                 })?;
 
-        // Transform statements
         let mut modified_schema_tables = HashSet::new();
-        for statement in &mut ast_vec {
+        if let Some(table_name) = transformer.transform_execute_statement_with_table_info(
-            if let Some(table_name) =
+            &mut statement,
-                transformer.transform_execute_statement(statement, &hlc_timestamp)?
+            &hlc_timestamp,
-            {
+        )? {
-                modified_schema_tables.insert(table_name);
+            modified_schema_tables.insert(table_name);
-            }
         }
 
-        // Convert parameters
+        let sql_str = statement.to_string();
-        let sql_values = ValueConverter::convert_params(params)?;
+        eprintln!("DEBUG: Transformed SQL (with RETURNING): {}", sql_str);
 
-        // Execute statements
+        // Prepare und query ausführen
-        for statement in ast_vec {
+        let mut stmt = tx
-            let sql_str = statement.to_string();
+            .prepare(&sql_str)
+            .map_err(|e| DatabaseError::ExecutionError {
+                sql: sql_str.clone(),
+                table: None,
+                reason: e.to_string(),
+            })?;
 
-            tx.execute(&sql_str, params_from_iter(sql_values.iter()))
+        let column_names: Vec<String> = stmt
-                .map_err(|e| DatabaseError::ExecutionError {
-                    sql: sql_str.clone(),
-                    table: None,
-                    reason: e.to_string(),
-                })?;
-
-            if let Statement::CreateTable(create_table_details) = statement {
-                let table_name_str = create_table_details.name.to_string();
-                trigger::setup_triggers_for_table(tx, &table_name_str, false)?;
-            }
-        }
-
-        Ok(modified_schema_tables)
-    }
-
-    /// Führt SELECT aus (mit CRDT-Transformation) - OHNE Permission-Check
-    pub fn select_internal(
-        conn: &rusqlite::Connection,
-        sql: &str,
-        params: &[JsonValue],
-    ) -> Result<Vec<JsonValue>, DatabaseError> {
-        // Parameter validation
-        let total_placeholders = sql.matches('?').count();
-        if total_placeholders != params.len() {
-            return Err(DatabaseError::ParameterMismatchError {
-                expected: total_placeholders,
-                provided: params.len(),
-                sql: sql.to_string(),
-            });
-        }
-
-        let mut ast_vec = parse_sql_statements(sql)?;
-
-        if ast_vec.is_empty() {
-            return Ok(vec![]);
-        }
-
-        // Validate that all statements are queries
-        for stmt in &ast_vec {
-            if !matches!(stmt, Statement::Query(_)) {
-                return Err(DatabaseError::ExecutionError {
-                    sql: sql.to_string(),
-                    reason: "Only SELECT statements are allowed".to_string(),
-                    table: None,
-                });
-            }
-        }
-
-        let sql_params = ValueConverter::convert_params(params)?;
-        let transformer = CrdtTransformer::new();
-
-        let last_statement = ast_vec.pop().unwrap();
-        let mut stmt_to_execute = last_statement;
-
-        transformer.transform_select_statement(&mut stmt_to_execute)?;
-        let transformed_sql = stmt_to_execute.to_string();
-
-        let mut prepared_stmt =
-            conn.prepare(&transformed_sql)
-                .map_err(|e| DatabaseError::ExecutionError {
-                    sql: transformed_sql.clone(),
-                    reason: e.to_string(),
-                    table: None,
-                })?;
-
-        let column_names: Vec<String> = prepared_stmt
             .column_names()
             .into_iter()
             .map(|s| s.to_string())
             .collect();
+        let num_columns = column_names.len();
 
-        let rows = prepared_stmt
+        let mut rows = stmt
-            .query_map(params_from_iter(sql_params.iter()), |row| {
+            .query(params_from_iter(params.iter()))
-                crate::extension::database::row_to_json_value(row, &column_names)
+            .map_err(|e| DatabaseError::ExecutionError {
-            })
+                sql: sql_str.clone(),
-            .map_err(|e| DatabaseError::QueryError {
+                table: None,
                 reason: e.to_string(),
             })?;
 
-        let mut results = Vec::new();
+        let mut result_vec: Vec<Vec<JsonValue>> = Vec::new();
-        for row_result in rows {
+
-            results.push(row_result.map_err(|e| DatabaseError::RowProcessingError {
+        // Lese alle RETURNING Zeilen
-                reason: e.to_string(),
+        while let Some(row) = rows.next().map_err(|e| DatabaseError::ExecutionError {
-            })?);
+            sql: sql_str.clone(),
+            table: None,
+            reason: e.to_string(),
+        })? {
+            let mut row_values: Vec<JsonValue> = Vec::new();
+            for i in 0..num_columns {
+                let value_ref = row.get_ref(i).map_err(|e| DatabaseError::ExecutionError {
+                    sql: sql_str.clone(),
+                    table: None,
+                    reason: e.to_string(),
+                })?;
+                let json_value = convert_value_ref_to_json(value_ref)?;
+                row_values.push(json_value);
+            }
+            result_vec.push(row_values);
         }
 
-        Ok(results)
+        // Trigger-Logik für CREATE TABLE
+        if let Statement::CreateTable(create_table_details) = statement {
+            let raw_name = create_table_details.name.to_string();
+            // Remove quotes from table name
+            let table_name_str = raw_name
+                .trim_matches('"')
+                .trim_matches('`')
+                .to_string();
+            eprintln!("DEBUG: Setting up triggers for table (RETURNING): {}", table_name_str);
+            trigger::setup_triggers_for_table(tx, &table_name_str, false)?;
+        }
+
+        Ok((modified_schema_tables, result_vec))
+    }
+
+    /// Führt ein einzelnes SQL Statement OHNE Typinformationen aus (JSON params)
+    pub fn execute_internal(
+        tx: &Transaction,
+        hlc_service: &HlcService,
+        sql: &str,
+        params: &[JsonValue],
+    ) -> Result<HashSet<String>, DatabaseError> {
+        let sql_params: Vec<SqliteValue> = params
+            .iter()
+            .map(|v| crate::database::core::ValueConverter::json_to_rusqlite_value(v))
+            .collect::<Result<Vec<_>, _>>()?;
+        let param_refs: Vec<&dyn ToSql> = sql_params.iter().map(|p| p as &dyn ToSql).collect();
+        Self::execute_internal_typed(tx, hlc_service, sql, &param_refs)
+    }
+
+    /// Query-Variante (mit RETURNING) OHNE Typinformationen (JSON params)
+    pub fn query_internal(
+        tx: &Transaction,
+        hlc_service: &HlcService,
+        sql: &str,
+        params: &[JsonValue],
+    ) -> Result<(HashSet<String>, Vec<Vec<JsonValue>>), DatabaseError> {
+        let sql_params: Vec<SqliteValue> = params
+            .iter()
+            .map(|v| crate::database::core::ValueConverter::json_to_rusqlite_value(v))
+            .collect::<Result<Vec<_>, _>>()?;
+        let param_refs: Vec<&dyn ToSql> = sql_params.iter().map(|p| p as &dyn ToSql).collect();
+        Self::query_internal_typed(tx, hlc_service, sql, &param_refs)
+    }
+
+    /// Führt mehrere SQL Statements als Batch aus
+    pub fn execute_batch_internal(
+        tx: &Transaction,
+        hlc_service: &HlcService,
+        sqls: &[String],
+        params: &[Vec<JsonValue>],
+    ) -> Result<HashSet<String>, DatabaseError> {
+        if sqls.len() != params.len() {
+            return Err(DatabaseError::ExecutionError {
+                sql: format!("{} statements but {} param sets", sqls.len(), params.len()),
+                reason: "Statement count and parameter count mismatch".to_string(),
+                table: None,
+            });
+        }
+
+        let mut all_modified_tables = HashSet::new();
+
+        for (sql, param_set) in sqls.iter().zip(params.iter()) {
+            let modified_tables = Self::execute_internal(tx, hlc_service, sql, param_set)?;
+            all_modified_tables.extend(modified_tables);
+        }
+
+        Ok(all_modified_tables)
+    }
+
+    /// Query für SELECT-Statements (read-only, kein CRDT nötig außer Filter)
+    pub fn query_select(
+        conn: &rusqlite::Connection,
+        sql: &str,
+        params: &[JsonValue],
+    ) -> Result<Vec<Vec<JsonValue>>, DatabaseError> {
+        let mut ast_vec = parse_sql_statements(sql)?;
+
+        if ast_vec.len() != 1 {
+            return Err(DatabaseError::ExecutionError {
+                sql: sql.to_string(),
+                reason: "query_select should only receive a single SELECT statement".to_string(),
+                table: None,
+            });
+        }
+
+        // Hard Delete: Keine SELECT-Transformation mehr nötig
+        let stmt_to_execute = ast_vec.pop().unwrap();
+        let transformed_sql = stmt_to_execute.to_string();
+
+        eprintln!("DEBUG: SELECT (no transformation): {}", transformed_sql);
+
+        // Convert JSON params to SQLite values
+        let sql_params: Vec<SqliteValue> = params
+            .iter()
+            .map(|v| crate::database::core::ValueConverter::json_to_rusqlite_value(v))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let mut prepared_stmt = conn.prepare(&transformed_sql)?;
+
+        let num_columns = prepared_stmt.column_count();
+
+        let param_refs: Vec<&dyn ToSql> = sql_params.iter().map(|p| p as &dyn ToSql).collect();
+
+        let mut rows = prepared_stmt.query(params_from_iter(param_refs.iter()))?;
+
+        let mut result: Vec<Vec<JsonValue>> = Vec::new();
+        while let Some(row) = rows.next()? {
+            let mut row_values: Vec<JsonValue> = Vec::new();
+            for i in 0..num_columns {
+                let value_ref = row.get_ref(i)?;
+                let json_value = convert_value_ref_to_json(value_ref)?;
+                row_values.push(json_value);
+            }
+            result.push(row_values);
+        }
+
+        Ok(result)
     }
 }

src-tauri/src/extension/database/mod.rs

@@ -5,6 +5,7 @@ use crate::crdt::transformer::CrdtTransformer;
 use crate::crdt::trigger;
 use crate::database::core::{parse_sql_statements, with_connection, ValueConverter};
 use crate::database::error::DatabaseError;
+use crate::extension::database::executor::SqlExecutor;
 use crate::extension::error::ExtensionError;
 use crate::extension::permissions::validator::SqlPermissionValidator;
 use crate::AppState;
@@ -107,11 +108,21 @@ impl<'a> StatementExecutor<'a> {
 pub async fn extension_sql_execute(
     sql: &str,
     params: Vec<JsonValue>,
-    extension_id: String,
+    public_key: String,
+    name: String,
     state: State<'_, AppState>,
-) -> Result<Vec<String>, ExtensionError> {
+) -> Result<Vec<Vec<JsonValue>>, ExtensionError> {
+    // Get extension to retrieve its ID
+    let extension = state
+        .extension_manager
+        .get_extension_by_public_key_and_name(&public_key, &name)?
+        .ok_or_else(|| ExtensionError::NotFound {
+            public_key: public_key.clone(),
+            name: name.clone(),
+        })?;
+
     // Permission check
-    SqlPermissionValidator::validate_sql(&state, &extension_id, sql).await?;
+    SqlPermissionValidator::validate_sql(&state, &extension.id, sql).await?;
 
     // Parameter validation
     validate_params(sql, &params)?;
@@ -119,58 +130,87 @@ pub async fn extension_sql_execute(
     // SQL parsing
     let mut ast_vec = parse_sql_statements(sql)?;
 
+    if ast_vec.len() != 1 {
+        return Err(ExtensionError::Database {
+            source: DatabaseError::ExecutionError {
+                sql: sql.to_string(),
+                reason: "extension_sql_execute should only receive a single SQL statement"
+                    .to_string(),
+                table: None,
+            },
+        });
+    }
+
+    let mut statement = ast_vec.pop().unwrap();
+
+    // Check if statement has RETURNING clause
+    let has_returning = crate::database::core::statement_has_returning(&statement);
+
     // Database operation
     with_connection(&state.db, |conn| {
         let tx = conn.transaction().map_err(DatabaseError::from)?;
 
         let transformer = CrdtTransformer::new();
-        let executor = StatementExecutor::new(&tx);
+
+        // Get HLC service reference
+        let hlc_service = state.hlc.lock().map_err(|_| DatabaseError::MutexPoisoned {
+            reason: "Failed to lock HLC service".to_string(),
+        })?;
 
         // Generate HLC timestamp
-        let hlc_timestamp = state
+        let hlc_timestamp = hlc_service
-            .hlc
-            .lock()
-            .unwrap()
             .new_timestamp_and_persist(&tx)
             .map_err(|e| DatabaseError::HlcError {
                 reason: e.to_string(),
             })?;
 
-        // Transform statements
+        // Transform statement
-        let mut modified_schema_tables = HashSet::new();
+        transformer.transform_execute_statement(&mut statement, &hlc_timestamp)?;
-        for statement in &mut ast_vec {
-            if let Some(table_name) =
-                transformer.transform_execute_statement(statement, &hlc_timestamp)?
-            {
-                modified_schema_tables.insert(table_name);
-            }
-        }
 
-        // Convert parameters
+        // Convert parameters to references
         let sql_values = ValueConverter::convert_params(&params)?;
+        let param_refs: Vec<&dyn rusqlite::ToSql> = sql_values.iter().map(|v| v as &dyn rusqlite::ToSql).collect();
 
-        // Execute statements
+        let result = if has_returning {
-        for statement in ast_vec {
+            // Use query_internal for statements with RETURNING
-            executor.execute_statement_with_params(&statement, &sql_values)?;
+            let (_, rows) = SqlExecutor::query_internal_typed(&tx, &hlc_service, &statement.to_string(), &param_refs)?;
+            rows
+        } else {
+            // Use execute_internal for statements without RETURNING
+            SqlExecutor::execute_internal_typed(&tx, &hlc_service, &statement.to_string(), &param_refs)?;
+            vec![]
+        };
 
-            if let Statement::CreateTable(create_table_details) = statement {
+        // Handle CREATE TABLE trigger setup
-                let table_name_str = create_table_details.name.to_string();
+        if let Statement::CreateTable(ref create_table_details) = statement {
-                println!(
+            // Extract table name and remove quotes (both " and `)
-                    "Table '{}' created by extension, setting up CRDT triggers...",
+            let raw_name = create_table_details.name.to_string();
-                    table_name_str
+            println!("DEBUG: Raw table name from AST: {:?}", raw_name);
-                );
+            println!("DEBUG: Raw table name chars: {:?}", raw_name.chars().collect::<Vec<_>>());
-                trigger::setup_triggers_for_table(&tx, &table_name_str, false)?;
+
-                println!(
+            let table_name_str = raw_name
-                    "Triggers for table '{}' successfully created.",
+                .trim_matches('"')
-                    table_name_str
+                .trim_matches('`')
-                );
+                .to_string();
-            }
+
+            println!("DEBUG: Cleaned table name: {:?}", table_name_str);
+            println!("DEBUG: Cleaned table name chars: {:?}", table_name_str.chars().collect::<Vec<_>>());
+
+            println!(
+                "Table '{}' created by extension, setting up CRDT triggers...",
+                table_name_str
+            );
+            trigger::setup_triggers_for_table(&tx, &table_name_str, false)?;
+            println!(
+                "Triggers for table '{}' successfully created.",
+                table_name_str
+            );
         }
 
         // Commit transaction
         tx.commit().map_err(DatabaseError::from)?;
 
-        Ok(modified_schema_tables.into_iter().collect())
+        Ok(result)
     })
     .map_err(ExtensionError::from)
 }
@@ -179,11 +219,21 @@ pub async fn extension_sql_execute(
 pub async fn extension_sql_select(
     sql: &str,
     params: Vec<JsonValue>,
-    extension_id: String,
+    public_key: String,
+    name: String,
     state: State<'_, AppState>,
-) -> Result<Vec<JsonValue>, ExtensionError> {
+) -> Result<Vec<Vec<JsonValue>>, ExtensionError> {
+    // Get extension to retrieve its ID
+    let extension = state
+        .extension_manager
+        .get_extension_by_public_key_and_name(&public_key, &name)?
+        .ok_or_else(|| ExtensionError::NotFound {
+            public_key: public_key.clone(),
+            name: name.clone(),
+        })?;
+
     // Permission check
-    SqlPermissionValidator::validate_sql(&state, &extension_id, sql).await?;
+    SqlPermissionValidator::validate_sql(&state, &extension.id, sql).await?;
 
     // Parameter validation
     validate_params(sql, &params)?;
@@ -209,17 +259,10 @@ pub async fn extension_sql_select(
         }
     }
 
-    // Database operation
+    // Database operation - return Vec<Vec<JsonValue>> like sql_select_with_crdt
     with_connection(&state.db, |conn| {
         let sql_params = ValueConverter::convert_params(&params)?;
-        let transformer = CrdtTransformer::new();
+        let stmt_to_execute = ast_vec.pop().unwrap();
-
-        // Use the last statement for result set
-        let last_statement = ast_vec.pop().unwrap();
-        let mut stmt_to_execute = last_statement;
-
-        // Transform the statement
-        transformer.transform_select_statement(&mut stmt_to_execute)?;
         let transformed_sql = stmt_to_execute.to_string();
 
         // Prepare and execute query
@@ -231,51 +274,34 @@ pub async fn extension_sql_select(
                     table: None,
                 })?;
 
-        let column_names: Vec<String> = prepared_stmt
+        let num_columns = prepared_stmt.column_count();
-            .column_names()
+        let mut rows = prepared_stmt
-            .into_iter()
+            .query(params_from_iter(sql_params.iter()))
-            .map(|s| s.to_string())
-            .collect();
-
-        let rows = prepared_stmt
-            .query_map(params_from_iter(sql_params.iter()), |row| {
-                row_to_json_value(row, &column_names)
-            })
             .map_err(|e| DatabaseError::QueryError {
                 reason: e.to_string(),
             })?;
 
-        let mut results = Vec::new();
+        let mut result_vec: Vec<Vec<JsonValue>> = Vec::new();
-        for row_result in rows {
+
-            results.push(row_result.map_err(|e| DatabaseError::RowProcessingError {
+        while let Some(row) = rows.next().map_err(|e| DatabaseError::QueryError {
-                reason: e.to_string(),
+            reason: e.to_string(),
-            })?);
+        })? {
+            let mut row_values: Vec<JsonValue> = Vec::new();
+            for i in 0..num_columns {
+                let value_ref = row.get_ref(i).map_err(|e| DatabaseError::QueryError {
+                    reason: e.to_string(),
+                })?;
+                let json_value = crate::database::core::convert_value_ref_to_json(value_ref)?;
+                row_values.push(json_value);
+            }
+            result_vec.push(row_values);
         }
 
-        Ok(results)
+        Ok(result_vec)
     })
     .map_err(ExtensionError::from)
 }
 
-/// Konvertiert eine SQLite-Zeile zu JSON
-fn row_to_json_value(
-    row: &rusqlite::Row,
-    columns: &[String],
-) -> Result<JsonValue, rusqlite::Error> {
-    let mut map = serde_json::Map::new();
-    for (i, col_name) in columns.iter().enumerate() {
-        let value = row.get::<usize, rusqlite::types::Value>(i)?;
-        let json_value = match value {
-            rusqlite::types::Value::Null => JsonValue::Null,
-            rusqlite::types::Value::Integer(i) => json!(i),
-            rusqlite::types::Value::Real(f) => json!(f),
-            rusqlite::types::Value::Text(s) => json!(s),
-            rusqlite::types::Value::Blob(blob) => json!(blob.to_vec()),
-        };
-        map.insert(col_name.clone(), json_value);
-    }
-    Ok(JsonValue::Object(map))
-}
 
 /// Validiert Parameter gegen SQL-Platzhalter
 fn validate_params(sql: &str, params: &[JsonValue]) -> Result<(), DatabaseError> {
@@ -297,15 +323,6 @@ fn count_sql_placeholders(sql: &str) -> usize {
     sql.matches('?').count()
 }
 
-/// Kürzt SQL für Fehlermeldungen
-/* fn truncate_sql(sql: &str, max_length: usize) -> String {
-    if sql.len() <= max_length {
-        sql.to_string()
-    } else {
-        format!("{}...", &sql[..max_length])
-    }
-} */
-
 #[cfg(test)]
 mod tests {
     use super::*;

src-tauri/src/extension/error.rs

@@ -9,14 +9,17 @@ pub enum ExtensionErrorCode {
     SecurityViolation = 1000,
     NotFound = 1001,
     PermissionDenied = 1002,
+    MutexPoisoned = 1003,
     Database = 2000,
     Filesystem = 2001,
+    FilesystemWithPath = 2004,
     Http = 2002,
     Shell = 2003,
     Manifest = 3000,
     Validation = 3001,
     InvalidPublicKey = 4000,
     InvalidSignature = 4001,
+    InvalidActionString = 4004,
     SignatureVerificationFailed = 4002,
     CalculateHash = 4003,
     Installation = 5000,
@@ -36,8 +39,8 @@ pub enum ExtensionError {
     #[error("Security violation: {reason}")]
     SecurityViolation { reason: String },
 
-    #[error("Extension not found: {id}")]
+    #[error("Extension not found: {name} (public_key: {public_key})")]
-    NotFound { id: String },
+    NotFound { public_key: String, name: String },
 
     #[error("Permission denied: {extension_id} cannot {operation} on {resource}")]
     PermissionDenied {
@@ -58,6 +61,12 @@ pub enum ExtensionError {
         source: std::io::Error,
     },
 
+    #[error("Filesystem operation failed at '{path}': {source}")]
+    FilesystemWithPath {
+        path: String,
+        source: std::io::Error,
+    },
+
     #[error("HTTP request failed: {reason}")]
     Http { reason: String },
 
@@ -76,6 +85,12 @@ pub enum ExtensionError {
     #[error("Invalid Public Key: {reason}")]
     InvalidPublicKey { reason: String },
 
+    #[error("Invalid Action: {input} for resource {resource_type}")]
+    InvalidActionString {
+        input: String,
+        resource_type: String,
+    },
+
     #[error("Invalid Signature: {reason}")]
     InvalidSignature { reason: String },
 
@@ -87,6 +102,9 @@ pub enum ExtensionError {
 
     #[error("Extension installation failed: {reason}")]
     InstallationFailed { reason: String },
+
+    #[error("A mutex was poisoned: {reason}")]
+    MutexPoisoned { reason: String },
 }
 
 impl ExtensionError {
@@ -98,6 +116,7 @@ impl ExtensionError {
             ExtensionError::PermissionDenied { .. } => ExtensionErrorCode::PermissionDenied,
             ExtensionError::Database { .. } => ExtensionErrorCode::Database,
             ExtensionError::Filesystem { .. } => ExtensionErrorCode::Filesystem,
+            ExtensionError::FilesystemWithPath { .. } => ExtensionErrorCode::FilesystemWithPath,
             ExtensionError::Http { .. } => ExtensionErrorCode::Http,
             ExtensionError::Shell { .. } => ExtensionErrorCode::Shell,
             ExtensionError::ManifestError { .. } => ExtensionErrorCode::Manifest,
@@ -109,6 +128,8 @@ impl ExtensionError {
             }
             ExtensionError::InstallationFailed { .. } => ExtensionErrorCode::Installation,
             ExtensionError::CalculateHashError { .. } => ExtensionErrorCode::CalculateHash,
+            ExtensionError::MutexPoisoned { .. } => ExtensionErrorCode::MutexPoisoned,
+            ExtensionError::InvalidActionString { .. } => ExtensionErrorCode::InvalidActionString,
         }
     }
 
@@ -133,6 +154,14 @@ impl ExtensionError {
             _ => None,
         }
     }
+
+    /// Helper to create a filesystem error with path context
+    pub fn filesystem_with_path<P: Into<String>>(path: P, source: std::io::Error) -> Self {
+        Self::FilesystemWithPath {
+            path: path.into(),
+            source,
+        }
+    }
 }
 
 impl serde::Serialize for ExtensionError {

src-tauri/src/extension/filesystem/permissions.rs

@@ -58,7 +58,7 @@ impl FilesystemPath {
     /// This would be implemented in your Tauri backend
     pub fn resolve_system_path(
         &self,
-        app_handle: &tauri::AppHandle,
+        _app_handle: &tauri::AppHandle,
     ) -> Result<String, ExtensionError> {
         /* let base_dir = match self.path_type {
             FilesystemPathType::AppData => app_handle.path().app_data_dir(),

src-tauri/src/extension/mod.rs

@@ -1,7 +1,7 @@
 /// src-tauri/src/extension/mod.rs
 use crate::{
     extension::{
-        core::{EditablePermissions, ExtensionInfoResponse, ExtensionPreview},
+        core::{manager::ExtensionManager, EditablePermissions, ExtensionInfoResponse, ExtensionPreview},
         error::ExtensionError,
     },
     AppState,
@@ -16,19 +16,45 @@ pub mod permissions;
 
 #[tauri::command]
 pub fn get_extension_info(
-    extension_id: String,
+    public_key: String,
+    name: String,
     state: State<AppState>,
-) -> Result<ExtensionInfoResponse, String> {
+) -> Result<ExtensionInfoResponse, ExtensionError> {
     let extension = state
         .extension_manager
-        .get_extension(&extension_id)
+        .get_extension_by_public_key_and_name(&public_key, &name)?
-        .ok_or_else(|| format!("Extension nicht gefunden: {}", extension_id))?;
+        .ok_or_else(|| ExtensionError::NotFound {
+            public_key: public_key.clone(),
+            name: name.clone(),
+        })?;
 
-    ExtensionInfoResponse::from_extension(&extension).map_err(|e| format!("{:?}", e))
+    ExtensionInfoResponse::from_extension(&extension)
 }
 
 #[tauri::command]
-pub fn get_all_extensions(state: State<AppState>) -> Result<Vec<ExtensionInfoResponse>, String> {
+pub async fn get_all_extensions(
+    app_handle: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<Vec<ExtensionInfoResponse>, String> {
+    // Check if extensions are loaded, if not load them first
+    /*  let needs_loading = {
+        let prod_exts = state
+            .extension_manager
+            .production_extensions
+            .lock()
+            .unwrap();
+        let dev_exts = state.extension_manager.dev_extensions.lock().unwrap();
+        prod_exts.is_empty() && dev_exts.is_empty()
+    }; */
+
+    /* if needs_loading { */
+    state
+        .extension_manager
+        .load_installed_extensions(&app_handle, &state)
+        .await
+        .map_err(|e| format!("Failed to load extensions: {:?}", e))?;
+    /* } */
+
     let mut extensions = Vec::new();
 
     // Production Extensions
@@ -56,19 +82,20 @@ pub fn get_all_extensions(state: State<AppState>) -> Result<Vec<ExtensionInfoRes
 
 #[tauri::command]
 pub async fn preview_extension(
+    app_handle: AppHandle,
     state: State<'_, AppState>,
-    source_path: String,
+    file_bytes: Vec<u8>,
 ) -> Result<ExtensionPreview, ExtensionError> {
     state
         .extension_manager
-        .preview_extension_internal(source_path)
+        .preview_extension_internal(&app_handle, file_bytes)
         .await
 }
 
 #[tauri::command]
 pub async fn install_extension_with_permissions(
     app_handle: AppHandle,
-    source_path: String,
+    file_bytes: Vec<u8>,
     custom_permissions: EditablePermissions,
     state: State<'_, AppState>,
 ) -> Result<String, ExtensionError> {
@@ -76,7 +103,7 @@ pub async fn install_extension_with_permissions(
         .extension_manager
         .install_extension_with_permissions_internal(
             app_handle,
-            source_path,
+            file_bytes,
             custom_permissions,
             &state,
         )
@@ -160,25 +187,246 @@ pub async fn install_extension(
 #[tauri::command]
 pub async fn remove_extension(
     app_handle: AppHandle,
-    extension_id: String,
+    public_key: String,
-    extension_version: String,
+    name: String,
+    version: String,
     state: State<'_, AppState>,
 ) -> Result<(), ExtensionError> {
     state
         .extension_manager
-        .remove_extension_internal(&app_handle, extension_id, extension_version, &state)
+        .remove_extension_internal(&app_handle, &public_key, &name, &version, &state)
         .await
 }
 
 #[tauri::command]
 pub fn is_extension_installed(
-    extension_id: String,
+    public_key: String,
+    name: String,
     extension_version: String,
     state: State<'_, AppState>,
-) -> Result<bool, String> {
+) -> Result<bool, ExtensionError> {
-    if let Some(ext) = state.extension_manager.get_extension(&extension_id) {
+    if let Some(ext) = state
+        .extension_manager
+        .get_extension_by_public_key_and_name(&public_key, &name)?
+    {
         Ok(ext.manifest.version == extension_version)
     } else {
         Ok(false)
     }
 }
+
+#[derive(serde::Deserialize, Debug)]
+struct HaextensionConfig {
+    dev: DevConfig,
+    #[serde(default)]
+    keys: KeysConfig,
+}
+
+#[derive(serde::Deserialize, Debug, Default)]
+struct KeysConfig {
+    #[serde(default)]
+    public_key_path: Option<String>,
+    #[serde(default)]
+    private_key_path: Option<String>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct DevConfig {
+    #[serde(default = "default_port")]
+    port: u16,
+    #[serde(default = "default_host")]
+    host: String,
+    #[serde(default = "default_haextension_dir")]
+    haextension_dir: String,
+}
+
+fn default_port() -> u16 {
+    5173
+}
+
+fn default_host() -> String {
+    "localhost".to_string()
+}
+
+fn default_haextension_dir() -> String {
+    "haextension".to_string()
+}
+
+/// Check if a dev server is reachable by making a simple HTTP request
+async fn check_dev_server_health(url: &str) -> bool {
+    use std::time::Duration;
+    use tauri_plugin_http::reqwest;
+
+    // Try to connect with a short timeout
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(3))
+        .build();
+
+    if let Ok(client) = client {
+        // Just check if the root responds (most dev servers respond to / with their app)
+        if let Ok(response) = client.get(url).send().await {
+            // Accept any response (200, 404, etc.) - we just want to know the server is running
+            return response.status().as_u16() < 500;
+        }
+    }
+
+    false
+}
+
+#[tauri::command]
+pub async fn load_dev_extension(
+    extension_path: String,
+    state: State<'_, AppState>,
+) -> Result<String, ExtensionError> {
+    use crate::extension::core::{
+        manifest::ExtensionManifest,
+        types::{Extension, ExtensionSource},
+    };
+    use std::path::PathBuf;
+    use std::time::SystemTime;
+
+    let extension_path_buf = PathBuf::from(&extension_path);
+
+    // 1. Read haextension.config.json to get dev server config and haextension directory
+    let config_path = extension_path_buf.join("haextension.config.json");
+    let (host, port, haextension_dir) = if config_path.exists() {
+        let config_content =
+            std::fs::read_to_string(&config_path).map_err(|e| ExtensionError::ValidationError {
+                reason: format!("Failed to read haextension.config.json: {}", e),
+            })?;
+
+        let config: HaextensionConfig =
+            serde_json::from_str(&config_content).map_err(|e| ExtensionError::ValidationError {
+                reason: format!("Failed to parse haextension.config.json: {}", e),
+            })?;
+
+        (config.dev.host, config.dev.port, config.dev.haextension_dir)
+    } else {
+        // Default values if config doesn't exist
+        (default_host(), default_port(), default_haextension_dir())
+    };
+
+    let dev_server_url = format!("http://{}:{}", host, port);
+    eprintln!("📡 Dev server URL: {}", dev_server_url);
+    eprintln!("📁 Haextension directory: {}", haextension_dir);
+
+    // 1.5. Check if dev server is running
+    if !check_dev_server_health(&dev_server_url).await {
+        return Err(ExtensionError::ValidationError {
+            reason: format!(
+                "Dev server at {} is not reachable. Please start your dev server first (e.g., 'npm run dev')",
+                dev_server_url
+            ),
+        });
+    }
+    eprintln!("✅ Dev server is reachable");
+
+    // 2. Validate and build path to manifest: <extension_path>/<haextension_dir>/manifest.json
+    let manifest_relative_path = format!("{}/manifest.json", haextension_dir);
+    let manifest_path = ExtensionManager::validate_path_in_directory(
+        &extension_path_buf,
+        &manifest_relative_path,
+        true,
+    )?
+    .ok_or_else(|| ExtensionError::ManifestError {
+        reason: format!(
+            "Manifest not found at: {}/manifest.json. Make sure you run 'npx @haexhub/sdk init' first.",
+            haextension_dir
+        ),
+    })?;
+
+    // 3. Read and parse manifest
+    let manifest_content =
+        std::fs::read_to_string(&manifest_path).map_err(|e| ExtensionError::ManifestError {
+            reason: format!("Failed to read manifest: {}", e),
+        })?;
+
+    let manifest: ExtensionManifest = serde_json::from_str(&manifest_content)?;
+
+    // 4. Generate a unique ID for dev extension: dev_<public_key>_<name>
+    let extension_id = format!("dev_{}_{}", manifest.public_key, manifest.name);
+
+    // 5. Check if dev extension already exists (allow reload)
+    if let Some(existing) = state
+        .extension_manager
+        .get_extension_by_public_key_and_name(&manifest.public_key, &manifest.name)?
+    {
+        // If it's already a dev extension, remove it first (to allow reload)
+        if let ExtensionSource::Development { .. } = &existing.source {
+            state
+                .extension_manager
+                .remove_extension(&manifest.public_key, &manifest.name)?;
+        }
+        // Note: Production extensions can coexist with dev extensions
+        // Dev extensions have priority during lookup
+    }
+
+    // 6. Create dev extension
+    let extension = Extension {
+        id: extension_id.clone(),
+        source: ExtensionSource::Development {
+            dev_server_url: dev_server_url.clone(),
+            manifest_path: manifest_path.clone(),
+            auto_reload: true,
+        },
+        manifest: manifest.clone(),
+        enabled: true,
+        last_accessed: SystemTime::now(),
+    };
+
+    // 7. Add to dev extensions (no database entry for dev extensions)
+    state.extension_manager.add_dev_extension(extension)?;
+
+    eprintln!(
+        "✅ Dev extension loaded: {} v{} ({})",
+        manifest.name, manifest.version, dev_server_url
+    );
+
+    Ok(extension_id)
+}
+
+#[tauri::command]
+pub fn remove_dev_extension(
+    public_key: String,
+    name: String,
+    state: State<'_, AppState>,
+) -> Result<(), ExtensionError> {
+    // Only remove from dev_extensions, not production_extensions
+    let mut dev_exts = state.extension_manager.dev_extensions.lock().map_err(|e| {
+        ExtensionError::MutexPoisoned {
+            reason: e.to_string(),
+        }
+    })?;
+
+    // Find and remove by public_key and name
+    let to_remove = dev_exts
+        .iter()
+        .find(|(_, ext)| ext.manifest.public_key == public_key && ext.manifest.name == name)
+        .map(|(id, _)| id.clone());
+
+    if let Some(id) = to_remove {
+        dev_exts.remove(&id);
+        eprintln!("✅ Dev extension removed: {}", name);
+        Ok(())
+    } else {
+        Err(ExtensionError::NotFound { public_key, name })
+    }
+}
+
+#[tauri::command]
+pub fn get_all_dev_extensions(
+    state: State<'_, AppState>,
+) -> Result<Vec<ExtensionInfoResponse>, ExtensionError> {
+    let dev_exts = state.extension_manager.dev_extensions.lock().map_err(|e| {
+        ExtensionError::MutexPoisoned {
+            reason: e.to_string(),
+        }
+    })?;
+
+    let mut extensions = Vec::new();
+    for ext in dev_exts.values() {
+        extensions.push(ExtensionInfoResponse::from_extension(ext)?);
+    }
+
+    Ok(extensions)
+}

src-tauri/src/extension/permissions/manager.rs

@@ -4,14 +4,10 @@ use crate::database::core::with_connection;
 use crate::database::error::DatabaseError;
 use crate::extension::database::executor::SqlExecutor;
 use crate::extension::error::ExtensionError;
-use crate::extension::permissions::types::{parse_constraints, Action, DbConstraints, ExtensionPermission, FsConstraints, HttpConstraints, PermissionConstraints, PermissionStatus, ResourceType, ShellConstraints};
+use crate::extension::permissions::types::{Action, ExtensionPermission, PermissionStatus, ResourceType};
-use serde_json;
-use serde_json::json;
-use std::path::Path;
 use tauri::State;
-use url::Url;
 use crate::database::generated::HaexExtensionPermissions;
-use rusqlite::{params, ToSql};
+use rusqlite::params;
 
 pub struct PermissionManager;
 
@@ -19,7 +15,6 @@ impl PermissionManager {
     /// Speichert alle Permissions einer Extension
     pub async fn save_permissions(
         app_state: &State<'_, AppState>,
-        extension_id: &str,
         permissions: &[ExtensionPermission],
     ) -> Result<(), ExtensionError> {
         with_connection(&app_state.db, |conn| {
@@ -162,6 +157,17 @@ impl PermissionManager {
             tx.commit().map_err(DatabaseError::from)
         }).map_err(ExtensionError::from)
     }
+
+    /// Löscht alle Permissions einer Extension innerhalb einer bestehenden Transaktion
+    pub fn delete_permissions_in_transaction(
+        tx: &rusqlite::Transaction,
+        hlc_service: &crate::crdt::hlc::HlcService,
+        extension_id: &str,
+    ) -> Result<(), DatabaseError> {
+        let sql = format!("DELETE FROM {} WHERE extension_id = ?", TABLE_EXTENSION_PERMISSIONS);
+        SqlExecutor::execute_internal_typed(tx, hlc_service, &sql, params![extension_id])?;
+        Ok(())
+    }
     /// Lädt alle Permissions einer Extension
     pub async fn get_permissions(
         app_state: &State<'_, AppState>,
@@ -184,8 +190,6 @@ impl PermissionManager {
         }).map_err(ExtensionError::from)
     }
 
-    
-
     /// Prüft Datenbankberechtigungen
    pub async fn check_database_permission(
         app_state: &State<'_, AppState>,
@@ -193,6 +197,30 @@ impl PermissionManager {
         action: Action,
         table_name: &str,
     ) -> Result<(), ExtensionError> {
+        // Remove quotes from table name if present (from SDK's getTableName())
+        let clean_table_name = table_name.trim_matches('"');
+
+        // Auto-allow: Extensions have full access to their own tables
+        // Table format: {publicKey}__{extensionName}__{tableName}
+        // Extension ID format: dev_{publicKey}_{extensionName} or {publicKey}_{extensionName}
+
+        // Get the extension to check if this is its own table
+        let extension = app_state
+            .extension_manager
+            .get_extension(extension_id)
+            .ok_or_else(|| ExtensionError::ValidationError {
+                reason: format!("Extension with ID {} not found", extension_id),
+            })?;
+
+        // Build expected table prefix: {publicKey}__{extensionName}__
+        let expected_prefix = format!("{}__{}__", extension.manifest.public_key, extension.manifest.name);
+
+        if clean_table_name.starts_with(&expected_prefix) {
+            // This is the extension's own table - auto-allow
+            return Ok(());
+        }
+
+        // Not own table - check explicit permissions
         let permissions = Self::get_permissions(app_state, extension_id).await?;
 
         let has_permission = permissions
@@ -201,7 +229,7 @@ impl PermissionManager {
             .filter(|perm| perm.resource_type == ResourceType::Db)
             .filter(|perm| perm.action == action) // action ist nicht mehr Option
             .any(|perm| {
-                if perm.target != "*" && perm.target != table_name {
+                if perm.target != "*" && perm.target != clean_table_name {
                     return false;
                 }
                 true

src-tauri/src/extension/permissions/types.rs

@@ -1,13 +1,159 @@
-// src-tauri/src/extension/permissions/types.rs
+use crate::extension::error::ExtensionError;
-
-use std::str::FromStr;
-
-use crate::{
-    database::{error::DatabaseError, generated::HaexExtensionPermissions},
-    extension::permissions::manager::PermissionManager,
-};
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use ts_rs::TS;
 
+// --- Spezifische Aktionen ---
+
+/// Definiert Aktionen, die auf eine Datenbank angewendet werden können.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
+pub enum DbAction {
+    Read,
+    ReadWrite,
+    Create,
+    Delete,
+    AlterDrop,
+}
+
+impl DbAction {
+    /// Prüft, ob diese Aktion Lesezugriff gewährt (implizites Recht).
+    pub fn allows_read(&self) -> bool {
+        matches!(self, DbAction::Read | DbAction::ReadWrite)
+    }
+
+    /// Prüft, ob diese Aktion Schreibzugriff gewährt.
+    pub fn allows_write(&self) -> bool {
+        matches!(
+            self,
+            DbAction::ReadWrite | DbAction::Create | DbAction::Delete
+        )
+    }
+}
+
+impl FromStr for DbAction {
+    type Err = ExtensionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "read" => Ok(DbAction::Read),
+            "readwrite" | "read_write" => Ok(DbAction::ReadWrite),
+            "create" => Ok(DbAction::Create),
+            "delete" => Ok(DbAction::Delete),
+            "alterdrop" | "alter_drop" => Ok(DbAction::AlterDrop),
+            _ => Err(ExtensionError::InvalidActionString {
+                input: s.to_string(),
+                resource_type: "database".to_string(),
+            }),
+        }
+    }
+}
+
+/// Definiert Aktionen, die auf das Dateisystem angewendet werden können.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
+pub enum FsAction {
+    Read,
+    ReadWrite,
+}
+
+impl FsAction {
+    /// Prüft, ob diese Aktion Lesezugriff gewährt (implizites Recht).
+    pub fn allows_read(&self) -> bool {
+        matches!(self, FsAction::Read | FsAction::ReadWrite)
+    }
+
+    /// Prüft, ob diese Aktion Schreibzugriff gewährt.
+    pub fn allows_write(&self) -> bool {
+        matches!(self, FsAction::ReadWrite)
+    }
+}
+
+impl FromStr for FsAction {
+    type Err = ExtensionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "read" => Ok(FsAction::Read),
+            "readwrite" | "read_write" => Ok(FsAction::ReadWrite),
+            _ => Err(ExtensionError::InvalidActionString {
+                input: s.to_string(),
+                resource_type: "filesystem".to_string(),
+            }),
+        }
+    }
+}
+
+/// Definiert Aktionen (HTTP-Methoden), die auf HTTP-Anfragen angewendet werden können.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "UPPERCASE")]
+#[ts(export)]
+pub enum HttpAction {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete,
+    #[serde(rename = "*")]
+    All,
+}
+
+impl FromStr for HttpAction {
+    type Err = ExtensionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_uppercase().as_str() {
+            "GET" => Ok(HttpAction::Get),
+            "POST" => Ok(HttpAction::Post),
+            "PUT" => Ok(HttpAction::Put),
+            "PATCH" => Ok(HttpAction::Patch),
+            "DELETE" => Ok(HttpAction::Delete),
+            "*" => Ok(HttpAction::All),
+            _ => Err(ExtensionError::InvalidActionString {
+                input: s.to_string(),
+                resource_type: "http".to_string(),
+            }),
+        }
+    }
+}
+
+/// Definiert Aktionen, die auf Shell-Befehle angewendet werden können.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[serde(rename_all = "lowercase")]
+#[ts(export)]
+pub enum ShellAction {
+    Execute,
+}
+
+impl FromStr for ShellAction {
+    type Err = ExtensionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "execute" => Ok(ShellAction::Execute),
+            _ => Err(ExtensionError::InvalidActionString {
+                input: s.to_string(),
+                resource_type: "shell".to_string(),
+            }),
+        }
+    }
+}
+
+// --- Haupt-Typen für Berechtigungen ---
+
+/// Ein typsicherer Container, der die spezifische Aktion für einen Ressourcentyp enthält.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
+#[ts(export)]
+pub enum Action {
+    Database(DbAction),
+    Filesystem(FsAction),
+    Http(HttpAction),
+    Shell(ShellAction),
+}
+
+/// Die interne Repräsentation einer einzelnen, gewährten Berechtigung.
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct ExtensionPermission {
     pub id: String,
@@ -18,62 +164,13 @@ pub struct ExtensionPermission {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub constraints: Option<PermissionConstraints>,
     pub status: PermissionStatus,
-
-    // CRDT Felder
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub haex_tombstone: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub haex_timestamp: Option<String>,
 }
 
-impl From<HaexExtensionPermissions> for ExtensionPermission {
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, TS)]
-    fn from(db_perm: HaexExtensionPermissions) -> Self {
-        let resource_type = ResourceType::from_str(&db_perm.resource_type.unwrap_or_default())
-            .unwrap_or(ResourceType::Db); // Fallback
-
-        let constraints = db_perm
-            .constraints
-            .and_then(|json_str| parse_constraints(&resource_type, &json_str).ok());
-
-        ExtensionPermission {
-            id: db_perm.id,
-            extension_id: db_perm.extension_id.unwrap_or_default(),
-            resource_type,
-            action: Action::from_str(&db_perm.action.unwrap_or_default()).unwrap_or(Action::Read),
-            target: db_perm.target.unwrap_or_default(),
-            status: PermissionStatus::from_str(&db_perm.status).unwrap_or(PermissionStatus::Ask),
-            constraints,
-            haex_timestamp: db_perm.haex_timestamp,
-            haex_tombstone: db_perm.haex_tombstone,
-        }
-    }
-}
-
-impl From<&ExtensionPermission> for HaexExtensionPermissions {
-    fn from(perm: &ExtensionPermission) -> Self {
-        let constraints_json = perm
-            .constraints
-            .as_ref()
-            .and_then(|c| serde_json::to_string(c).ok());
-
-        HaexExtensionPermissions {
-            id: perm.id.clone(),
-            extension_id: Some(perm.extension_id.clone()),
-            resource_type: Some(format!("{:?}", perm.resource_type).to_lowercase()),
-            action: Some(format!("{:?}", perm.action).to_lowercase()),
-            target: Some(perm.target.clone()),
-            constraints: constraints_json,
-            status: perm.status.as_str().to_string(),
-            created_at: None, // Wird von der DB gesetzt
-            updated_at: None, // Wird von der DB gesetzt
-            haex_timestamp: perm.haex_timestamp.clone(),
-            haex_tombstone: perm.haex_tombstone,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "lowercase")]
+#[ts(export)]
 pub enum ResourceType {
     Fs,
     Http,
@@ -81,49 +178,140 @@ pub enum ResourceType {
     Shell,
 }
 
-impl FromStr for ResourceType {
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, TS)]
-    type Err = DatabaseError;
+#[serde(rename_all = "lowercase")]
+#[ts(export)]
+pub enum PermissionStatus {
+    Ask,
+    Granted,
+    Denied,
+}
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+// --- Constraint-Typen (unverändert) ---
+
+#[derive(Serialize, Deserialize, Clone, Debug, TS)]
+#[serde(untagged)]
+#[ts(export)]
+pub enum PermissionConstraints {
+    Database(DbConstraints),
+    Filesystem(FsConstraints),
+    Http(HttpConstraints),
+    Shell(ShellConstraints),
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
+#[ts(export)]
+pub struct DbConstraints {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub where_clause: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub columns: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<u32>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
+#[ts(export)]
+pub struct FsConstraints {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_file_size: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allowed_extensions: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<bool>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
+#[ts(export)]
+pub struct HttpConstraints {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub methods: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rate_limit: Option<RateLimit>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, TS)]
+#[ts(export)]
+pub struct RateLimit {
+    pub requests: u32,
+    pub per_minutes: u32,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, TS)]
+#[ts(export)]
+pub struct ShellConstraints {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allowed_subcommands: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allowed_flags: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub forbidden_args: Option<Vec<String>>,
+}
+
+// --- Konvertierungen zwischen ExtensionPermission und HaexExtensionPermissions ---
+
+impl ResourceType {
+    pub fn as_str(&self) -> &str {
+        match self {
+            ResourceType::Fs => "fs",
+            ResourceType::Http => "http",
+            ResourceType::Db => "db",
+            ResourceType::Shell => "shell",
+        }
+    }
+
+    pub fn from_str(s: &str) -> Result<Self, ExtensionError> {
         match s {
             "fs" => Ok(ResourceType::Fs),
             "http" => Ok(ResourceType::Http),
             "db" => Ok(ResourceType::Db),
             "shell" => Ok(ResourceType::Shell),
-            _ => Err(DatabaseError::SerializationError {
+            _ => Err(ExtensionError::ValidationError {
-                reason: format!("Unbekannter Ressourcentyp: {}", s),
+                reason: format!("Unknown resource type: {}", s),
             }),
         }
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+impl Action {
-#[serde(rename_all = "lowercase")]
+    pub fn as_str(&self) -> String {
-pub enum Action {
+        match self {
-    Read,
+            Action::Database(action) => serde_json::to_string(action)
-    Write,
+                .unwrap_or_default()
-}
+                .trim_matches('"')
-
+                .to_string(),
-impl FromStr for Action {
+            Action::Filesystem(action) => serde_json::to_string(action)
-    type Err = DatabaseError;
+                .unwrap_or_default()
-
+                .trim_matches('"')
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+                .to_string(),
-        match s {
+            Action::Http(action) => serde_json::to_string(action)
-            "read" => Ok(Action::Read),
+                .unwrap_or_default()
-            "write" => Ok(Action::Write),
+                .trim_matches('"')
-            _ => Err(DatabaseError::SerializationError {
+                .to_string(),
-                reason: format!("Unbekannte Aktion: {}", s),
+            Action::Shell(action) => serde_json::to_string(action)
-            }),
+                .unwrap_or_default()
+                .trim_matches('"')
+                .to_string(),
         }
     }
-}
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+    pub fn from_str(resource_type: &ResourceType, s: &str) -> Result<Self, ExtensionError> {
-#[serde(rename_all = "lowercase")]
+        match resource_type {
-pub enum PermissionStatus {
+            ResourceType::Db => Ok(Action::Database(DbAction::from_str(s)?)),
-    Ask,
+            ResourceType::Fs => Ok(Action::Filesystem(FsAction::from_str(s)?)),
-    Granted,
+            ResourceType::Http => {
-    Denied,
+                let action: HttpAction =
+                    serde_json::from_str(&format!("\"{}\"", s)).map_err(|_| {
+                        ExtensionError::InvalidActionString {
+                            input: s.to_string(),
+                            resource_type: "http".to_string(),
+                        }
+                    })?;
+                Ok(Action::Http(action))
+            }
+            ResourceType::Shell => Ok(Action::Shell(ShellAction::from_str(s)?)),
+        }
+    }
 }
 
 impl PermissionStatus {
@@ -135,140 +323,69 @@ impl PermissionStatus {
         }
     }
 
-    pub fn from_str(s: &str) -> Result<Self, DatabaseError> {
+    pub fn from_str(s: &str) -> Result<Self, ExtensionError> {
         match s {
             "ask" => Ok(PermissionStatus::Ask),
             "granted" => Ok(PermissionStatus::Granted),
             "denied" => Ok(PermissionStatus::Denied),
-            _ => Err(DatabaseError::SerializationError {
+            _ => Err(ExtensionError::ValidationError {
                 reason: format!("Unknown permission status: {}", s),
             }),
         }
     }
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+impl From<&ExtensionPermission> for crate::database::generated::HaexExtensionPermissions {
-#[serde(untagged)]
+    fn from(perm: &ExtensionPermission) -> Self {
-pub enum PermissionConstraints {
+        Self {
-    Database(DbConstraints),
+            id: perm.id.clone(),
-    Filesystem(FsConstraints),
+            extension_id: perm.extension_id.clone(),
-    Http(HttpConstraints),
+            resource_type: Some(perm.resource_type.as_str().to_string()),
-    Shell(ShellConstraints),
+            action: Some(perm.action.as_str().to_string()),
-}
+            target: Some(perm.target.clone()),
-
+            constraints: perm
-#[derive(Serialize, Deserialize, Clone, Debug)]
+                .constraints
-pub struct DbConstraints {
+                .as_ref()
-    #[serde(skip_serializing_if = "Option::is_none")]
+                .and_then(|c| serde_json::to_string(c).ok()),
-    pub where_clause: Option<String>,
+            status: perm.status.as_str().to_string(),
-    #[serde(skip_serializing_if = "Option::is_none")]
+            created_at: None,
-    pub columns: Option<Vec<String>>,
+            updated_at: None,
-    #[serde(skip_serializing_if = "Option::is_none")]
+            haex_timestamp: perm.haex_timestamp.clone(),
-    pub limit: Option<u32>,
+        }
-}
+    }
-
+}
-#[derive(Serialize, Deserialize, Clone, Debug)]
+
-pub struct FsConstraints {
+impl From<crate::database::generated::HaexExtensionPermissions> for ExtensionPermission {
-    #[serde(skip_serializing_if = "Option::is_none")]
+    fn from(db_perm: crate::database::generated::HaexExtensionPermissions) -> Self {
-    pub max_file_size: Option<u64>,
+        let resource_type = db_perm
-    #[serde(skip_serializing_if = "Option::is_none")]
+            .resource_type
-    pub allowed_extensions: Option<Vec<String>>,
+            .as_deref()
-    #[serde(skip_serializing_if = "Option::is_none")]
+            .and_then(|s| ResourceType::from_str(s).ok())
-    pub recursive: Option<bool>,
+            .unwrap_or(ResourceType::Db);
-}
+
-
+        let action = db_perm
-#[derive(Serialize, Deserialize, Clone, Debug)]
+            .action
-pub struct HttpConstraints {
+            .as_deref()
-    #[serde(skip_serializing_if = "Option::is_none")]
+            .and_then(|s| Action::from_str(&resource_type, s).ok())
-    pub methods: Option<Vec<String>>,
+            .unwrap_or(Action::Database(DbAction::Read));
-    #[serde(skip_serializing_if = "Option::is_none")]
+
-    pub rate_limit: Option<RateLimit>,
+        let status =
-}
+            PermissionStatus::from_str(db_perm.status.as_str()).unwrap_or(PermissionStatus::Denied);
-
+
-#[derive(Serialize, Deserialize, Clone, Debug)]
+        let constraints = db_perm
-pub struct RateLimit {
+            .constraints
-    pub requests: u32,
+            .as_deref()
-    pub per_minutes: u32,
+            .and_then(|s| serde_json::from_str(s).ok());
-}
+
-
+        Self {
-#[derive(Serialize, Deserialize, Clone, Debug)]
+            id: db_perm.id,
-pub struct ShellConstraints {
+            extension_id: db_perm.extension_id,
-    #[serde(skip_serializing_if = "Option::is_none")]
+            resource_type,
-    pub allowed_subcommands: Option<Vec<String>>,
+            action,
-    #[serde(skip_serializing_if = "Option::is_none")]
+            target: db_perm.target.unwrap_or_default(),
-    pub allowed_flags: Option<Vec<String>>,
+            constraints,
-    #[serde(skip_serializing_if = "Option::is_none")]
+            status,
-    pub forbidden_args: Option<Vec<String>>,
+            haex_timestamp: db_perm.haex_timestamp,
-}
-
-// Wenn du weiterhin gruppierte Permissions brauchst:
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct EditablePermissions {
-    pub permissions: Vec<ExtensionPermission>,
-}
-
-// Oder gruppiert nach Typ:
-/* impl EditablePermissions {
-    pub fn database_permissions(&self) -> Vec<&ExtensionPermission> {
-        self.permissions
-            .iter()
-            .filter(|p| p.resource_type == ResourceType::Db)
-            .collect()
-    }
-
-    pub fn filesystem_permissions(&self) -> Vec<&ExtensionPermission> {
-        self.permissions
-            .iter()
-            .filter(|p| p.resource_type == ResourceType::Fs)
-            .collect()
-    }
-
-    pub fn http_permissions(&self) -> Vec<&ExtensionPermission> {
-        self.permissions
-            .iter()
-            .filter(|p| p.resource_type == ResourceType::Http)
-            .collect()
-    }
-
-    pub fn shell_permissions(&self) -> Vec<&ExtensionPermission> {
-        self.permissions
-            .iter()
-            .filter(|p| p.resource_type == ResourceType::Shell)
-            .collect()
-    }
-} */
-
-pub fn parse_constraints(
-    resource_type: &ResourceType,
-    json: &str,
-) -> Result<PermissionConstraints, DatabaseError> {
-    match resource_type {
-        ResourceType::Db => {
-            let constraints: DbConstraints =
-                serde_json::from_str(json).map_err(|e| DatabaseError::SerializationError {
-                    reason: format!("Failed to parse DB constraints: {}", e),
-                })?;
-            Ok(PermissionConstraints::Database(constraints))
-        }
-        ResourceType::Fs => {
-            let constraints: FsConstraints =
-                serde_json::from_str(json).map_err(|e| DatabaseError::SerializationError {
-                    reason: format!("Failed to parse FS constraints: {}", e),
-                })?;
-            Ok(PermissionConstraints::Filesystem(constraints))
-        }
-        ResourceType::Http => {
-            let constraints: HttpConstraints =
-                serde_json::from_str(json).map_err(|e| DatabaseError::SerializationError {
-                    reason: format!("Failed to parse HTTP constraints: {}", e),
-                })?;
-            Ok(PermissionConstraints::Http(constraints))
-        }
-        ResourceType::Shell => {
-            let constraints: ShellConstraints =
-                serde_json::from_str(json).map_err(|e| DatabaseError::SerializationError {
-                    reason: format!("Failed to parse Shell constraints: {}", e),
-                })?;
-            Ok(PermissionConstraints::Shell(constraints))
         }
     }
 }

src-tauri/src/extension/permissions/validator.rs

@@ -12,6 +12,14 @@ use tauri::State;
 pub struct SqlPermissionValidator;
 
 impl SqlPermissionValidator {
+    /// Prüft ob eine Tabelle zur Extension gehört (basierend auf keyHash Präfix)
+    /// Format: {keyHash}_{extensionName}_{tableName}
+    fn is_own_table(extension_id: &str, table_name: &str) -> bool {
+        // Tabellennamen sind im Format: {keyHash}_{extensionName}_{tableName}
+        // extension_id ist der keyHash der Extension
+        table_name.starts_with(&format!("{}_", extension_id))
+    }
+
     /// Validiert ein SQL-Statement gegen die Permissions einer Extension
     pub async fn validate_sql(
         app_state: &State<'_, AppState>,
@@ -54,7 +62,7 @@ impl SqlPermissionValidator {
             PermissionManager::check_database_permission(
                 app_state,
                 extension_id,
-                Action::Read,
+                Action::Database(super::types::DbAction::Read),
                 &table_name,
             )
             .await?;
@@ -75,7 +83,7 @@ impl SqlPermissionValidator {
             PermissionManager::check_database_permission(
                 app_state,
                 extension_id,
-                Action::Write,
+                Action::Database(super::types::DbAction::ReadWrite),
                 &table_name,
             )
             .await?;
@@ -97,7 +105,7 @@ impl SqlPermissionValidator {
             PermissionManager::check_database_permission(
                 app_state,
                 extension_id,
-                Action::Write,
+                Action::Database(super::types::DbAction::Create),
                 &table_name,
             )
             .await?;
@@ -119,7 +127,7 @@ impl SqlPermissionValidator {
             PermissionManager::check_database_permission(
                 app_state,
                 extension_id,
-                Action::Write,
+                Action::Database(super::types::DbAction::AlterDrop),
                 &table_name,
             )
             .await?;

src-tauri/src/lib.rs

@@ -1,11 +1,7 @@
 mod crdt;
 mod database;
 mod extension;
-use crate::{
+use crate::{crdt::hlc::HlcService, database::DbConnection, extension::core::ExtensionManager};
-    crdt::hlc::HlcService,
-    database::DbConnection,
-    extension::core::{ExtensionManager, ExtensionState},
-};
 use std::sync::{Arc, Mutex};
 use tauri::Manager;
 
@@ -21,10 +17,10 @@ pub struct AppState {
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    let protocol_name = "haex-extension";
+    use extension::core::EXTENSION_PROTOCOL_NAME;
 
     tauri::Builder::default()
-        .register_uri_scheme_protocol(protocol_name, move |context, request| {
+        .register_uri_scheme_protocol(EXTENSION_PROTOCOL_NAME, move |context, request| {
             // Hole den AppState aus dem Context
             let app_handle = context.app_handle();
             let state = app_handle.state::<AppState>();
@@ -60,7 +56,7 @@ pub fn run() {
             hlc: Mutex::new(HlcService::new()),
             extension_manager: ExtensionManager::new(),
         })
-        .manage(ExtensionState::default())
+        //.manage(ExtensionState::default())
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_http::init())
@@ -72,18 +68,25 @@ pub fn run() {
         .invoke_handler(tauri::generate_handler![
             database::create_encrypted_database,
             database::delete_vault,
+            database::move_vault_to_trash,
             database::list_vaults,
             database::open_encrypted_database,
+            database::sql_execute_with_crdt,
             database::sql_execute,
+            database::sql_query_with_crdt,
+            database::sql_select_with_crdt,
             database::sql_select,
             database::vault_exists,
             extension::database::extension_sql_execute,
             extension::database::extension_sql_select,
+            extension::get_all_dev_extensions,
             extension::get_all_extensions,
             extension::get_extension_info,
             extension::install_extension_with_permissions,
             extension::is_extension_installed,
+            extension::load_dev_extension,
             extension::preview_extension,
+            extension::remove_dev_extension,
             extension::remove_extension,
         ])
         .run(tauri::generate_context!())

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "haex-hub",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "identifier": "space.haex.hub",
   "build": {
     "beforeDevCommand": "pnpm dev",
@@ -9,6 +9,7 @@
     "beforeBuildCommand": "pnpm generate",
     "frontendDist": "../dist"
   },
+
   "app": {
     "windows": [
       {
@@ -19,25 +20,41 @@
     ],
     "security": {
       "csp": {
-        "default-src": ["'self'", "http://tauri.localhost"],
+        "default-src": ["'self'", "http://tauri.localhost", "haex-extension:"],
         "script-src": [
           "'self'",
           "http://tauri.localhost",
-          "'wasm-unsafe-eval'"
+          "haex-extension:",
+          "'wasm-unsafe-eval'",
+          "'unsafe-inline'"
+        ],
+        "style-src": [
+          "'self'",
+          "http://tauri.localhost",
+          "haex-extension:",
+          "'unsafe-inline'"
         ],
-        "style-src": ["'self'", "http://tauri.localhost", "'unsafe-inline'"],
         "connect-src": [
           "'self'",
           "http://tauri.localhost",
+          "haex-extension:",
           "ipc:",
-          "http://ipc.localhost"
+          "http://ipc.localhost",
+          "ws://localhost:*"
         ],
-        "img-src": ["'self'", "http://tauri.localhost", "data:", "blob:"],
+        "img-src": [
-        "font-src": ["'self'", "http://tauri.localhost"],
+          "'self'",
+          "http://tauri.localhost",
+          "haex-extension:",
+          "data:",
+          "blob:"
+        ],
+        "font-src": ["'self'", "http://tauri.localhost", "haex-extension:"],
         "object-src": ["'none'"],
-        "media-src": ["'self'", "http://tauri.localhost"],
+        "media-src": ["'self'", "http://tauri.localhost", "haex-extension:"],
-        "frame-src": ["'none'"],
+        "frame-src": ["haex-extension:"],
-        "frame-ancestors": ["'none'"]
+        "frame-ancestors": ["'none'"],
+        "base-uri": ["'self'"]
       },
       "assetProtocol": {
         "enable": true,

src/app.config.ts

@@ -2,7 +2,9 @@ export default defineAppConfig({
   ui: {
     colors: {
       primary: 'sky',
-      secondary: 'purple',
+      secondary: 'fuchsia',
+      warning: 'yellow',
+      danger: 'red',
     },
   },
 })

src/app.vue

@@ -1,14 +1,17 @@
 <template>
   <UApp :locale="locales[locale]">
-    <NuxtLayout>
+    <div data-vaul-drawer-wrapper>
       <NuxtPage />
-    </NuxtLayout>
+    </div>
   </UApp>
 </template>
 
 <script setup lang="ts">
 import * as locales from '@nuxt/ui/locale'
 const { locale } = useI18n()
+
+// Handle Android back button
+useAndroidBackButton()
 </script>
 
 <style>

src/assets/css/main.css

@@ -13,8 +13,48 @@
   [disabled] {
     @apply cursor-not-allowed;
   }
+
+  /* Define safe-area-insets as CSS custom properties for JavaScript access */
+  :root {
+    --safe-area-inset-top: env(safe-area-inset-top, 0px);
+    --safe-area-inset-bottom: env(safe-area-inset-bottom, 0px);
+    --safe-area-inset-left: env(safe-area-inset-left, 0px);
+    --safe-area-inset-right: env(safe-area-inset-right, 0px);
+  }
+
+  /* Verhindere Scrolling auf html und body */
+  html {
+    overflow: hidden;
+    margin: 0;
+    padding: 0;
+    height: 100dvh;
+    height: 100vh; /* Fallback */
+    width: 100%;
+  }
+
+  body {
+    overflow: hidden;
+    margin: 0;
+    height: 100%;
+    width: 100%;
+    padding: 0;
+  }
+
+  #__nuxt {
+    /* Volle Höhe des body */
+    height: 100%;
+    width: 100%;
+
+    /* Safe-Area Paddings auf root element - damit ALLES davon profitiert */
+    padding-top: var(--safe-area-inset-top);
+    padding-bottom: var(--safe-area-inset-bottom);
+    padding-left: var(--safe-area-inset-left);
+    padding-right: var(--safe-area-inset-right);
+
+    box-sizing: border-box;
+  }
 }
 
-:root {
+@theme {
-  --ui-header-height: 74px;
+  --spacing-header: 3.5rem; /* 72px - oder dein Wunschwert */
 }

src/components/haex/debug/overlay.vue

@@ -0,0 +1,61 @@
+<template>
+  <div
+    v-if="data"
+    class="fixed top-2 right-2 bg-black/90 text-white text-xs p-3 rounded-lg shadow-2xl max-w-sm z-[9999] backdrop-blur-sm"
+  >
+    <div class="flex justify-between items-start gap-3 mb-2">
+      <span class="font-bold text-sm">{{ title }}</span>
+      <div class="flex gap-1">
+        <button
+          class="bg-white/20 hover:bg-white/30 px-2 py-1 rounded text-xs transition-colors"
+          @click="copyToClipboardAsync"
+        >
+          Copy
+        </button>
+        <button
+          v-if="dismissible"
+          class="bg-white/20 hover:bg-white/30 px-2 py-1 rounded text-xs transition-colors"
+          @click="handleDismiss"
+        >
+          ✕
+        </button>
+      </div>
+    </div>
+    <pre class="text-xs whitespace-pre-wrap font-mono overflow-auto max-h-96">{{ formattedData }}</pre>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = withDefaults(
+  defineProps<{
+    data: Record<string, any> | null
+    title?: string
+    dismissible?: boolean
+  }>(),
+  {
+    title: 'Debug Info',
+    dismissible: false,
+  },
+)
+
+const emit = defineEmits<{
+  dismiss: []
+}>()
+
+const formattedData = computed(() => {
+  if (!props.data) return ''
+  return JSON.stringify(props.data, null, 2)
+})
+
+const copyToClipboardAsync = async () => {
+  try {
+    await navigator.clipboard.writeText(formattedData.value)
+  } catch (err) {
+    console.error('Failed to copy debug info:', err)
+  }
+}
+
+const handleDismiss = () => {
+  emit('dismiss')
+}
+</script>

src/components/haex/desktop/extension-frame.vue

@@ -0,0 +1,169 @@
+<template>
+  <div class="w-full h-full relative">
+    <!-- Error overlay for dev extensions when server is not reachable -->
+    <div
+      v-if="extension?.devServerUrl && hasError"
+      class="absolute inset-0 bg-white dark:bg-gray-900 flex items-center justify-center p-8"
+    >
+      <div class="max-w-md space-y-4 text-center">
+        <UIcon
+          name="i-heroicons-exclamation-circle"
+          class="w-16 h-16 mx-auto text-yellow-500"
+        />
+        <h3 class="text-lg font-semibold">Dev Server Not Reachable</h3>
+        <p class="text-sm opacity-70">
+          The dev server at {{ extension.devServerUrl }} is not reachable.
+        </p>
+        <div
+          class="bg-gray-100 dark:bg-gray-800 p-4 rounded text-left text-xs font-mono"
+        >
+          <p class="opacity-70 mb-2">To start the dev server:</p>
+          <code class="block">cd /path/to/extension</code>
+          <code class="block">npm run dev</code>
+        </div>
+        <UButton
+          label="Retry"
+          @click="retryLoad"
+        />
+      </div>
+    </div>
+
+    <!-- Loading Spinner -->
+    <div
+      v-if="isLoading"
+      class="absolute inset-0 bg-white dark:bg-gray-900 flex items-center justify-center"
+    >
+      <div class="flex flex-col items-center gap-4">
+        <div
+          class="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500"
+        />
+        <p class="text-sm text-gray-600 dark:text-gray-400">
+          Loading extension...
+        </p>
+      </div>
+    </div>
+
+    <iframe
+      ref="iframeRef"
+      :class="[
+        'w-full h-full border-0 transition-all duration-1000 ease-out',
+        isLoading ? 'opacity-0 scale-0' : 'opacity-100 scale-100',
+      ]"
+      :src="extensionUrl"
+      :sandbox="sandboxAttributes"
+      allow="autoplay; speaker-selection; encrypted-media;"
+      @load="handleIframeLoad"
+      @error="hasError = true"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import {
+  EXTENSION_PROTOCOL_PREFIX,
+  EXTENSION_PROTOCOL_NAME,
+} from '~/config/constants'
+
+const props = defineProps<{
+  extensionId: string
+  windowId: string 
+}>()
+
+const extensionsStore = useExtensionsStore()
+const { platform } = useDeviceStore()
+
+const iframeRef = useTemplateRef('iframeRef')
+const hasError = ref(false)
+const isLoading = ref(true)
+
+// Convert windowId to ref for reactive tracking
+const windowIdRef = toRef(props, 'windowId')
+
+const extension = computed(() => {
+  return extensionsStore.availableExtensions.find(
+    (ext) => ext.id === props.extensionId,
+  )
+})
+
+const handleIframeLoad = () => {
+  // Delay the fade-in slightly to allow window animation to mostly complete
+  setTimeout(() => {
+    isLoading.value = false
+  }, 200)
+}
+
+const sandboxDefault = ['allow-scripts'] as const
+
+const sandboxAttributes = computed(() => {
+  return extension.value?.devServerUrl
+    ? [...sandboxDefault, 'allow-same-origin'].join(' ')
+    : sandboxDefault.join(' ')
+})
+
+// Generate extension URL
+const extensionUrl = computed(() => {
+  if (!extension.value) return ''
+
+  const { publicKey, name, version, devServerUrl } = extension.value
+  const assetPath = 'index.html'
+
+  if (!publicKey || !name || !version) {
+    console.error('Missing required extension fields')
+    return ''
+  }
+
+  // If dev server URL is provided, load directly from dev server
+  if (devServerUrl) {
+    const cleanUrl = devServerUrl.replace(/\/$/, '')
+    const cleanPath = assetPath.replace(/^\//, '')
+    return cleanPath ? `${cleanUrl}/${cleanPath}` : cleanUrl
+  }
+
+  const extensionInfo = {
+    name,
+    publicKey,
+    version,
+  }
+  const encodedInfo = btoa(JSON.stringify(extensionInfo))
+
+  if (platform === 'android' || platform === 'windows') {
+    // Android: Tauri uses http://{scheme}.localhost format
+    return `http://${EXTENSION_PROTOCOL_NAME}.localhost/${encodedInfo}/${assetPath}`
+  } else {
+    // Desktop: Use custom protocol with base64 as host
+    return `${EXTENSION_PROTOCOL_PREFIX}${encodedInfo}/${assetPath}`
+  }
+})
+
+const retryLoad = () => {
+  hasError.value = false
+  if (iframeRef.value) {
+    //iframeRef.value.src = iframeRef.value.src // Force reload
+  }
+}
+
+// Initialize extension message handler to set up context
+useExtensionMessageHandler(iframeRef, extension, windowIdRef)
+
+// Additional explicit registration on mount to ensure iframe is registered
+onMounted(() => {
+  // Wait for iframe to be ready
+  if (iframeRef.value && extension.value) {
+    console.log(
+      '[ExtensionFrame] Manually registering iframe on mount',
+      extension.value.name,
+      'windowId:',
+      props.windowId,
+    )
+    registerExtensionIFrame(iframeRef.value, extension.value, props.windowId)
+  }
+})
+
+// Explicit cleanup before unmount
+onBeforeUnmount(() => {
+  if (iframeRef.value) {
+    console.log('[ExtensionFrame] Unregistering iframe on unmount')
+    unregisterExtensionIFrame(iframeRef.value)
+  }
+})
+</script>

src/components/haex/desktop/icon.vue

@@ -0,0 +1,227 @@
+<template>
+  <div>
+    <UiDialogConfirm
+      v-model:open="showUninstallDialog"
+      :title="t('confirmUninstall.title')"
+      :description="t('confirmUninstall.message', { name: label })"
+      :confirm-label="t('confirmUninstall.confirm')"
+      :abort-label="t('confirmUninstall.cancel')"
+      confirm-icon="i-heroicons-trash"
+      @confirm="handleConfirmUninstall"
+    />
+
+    <UContextMenu :items="contextMenuItems">
+      <div
+        ref="draggableEl"
+        :style="style"
+        class="select-none cursor-grab active:cursor-grabbing"
+        @pointerdown.left="handlePointerDown"
+        @pointermove="handlePointerMove"
+        @pointerup="handlePointerUp"
+        @click.left="handleClick"
+        @dblclick="handleDoubleClick"
+      >
+        <div class="flex flex-col items-center gap-2 p-3 group">
+          <div
+            :class="[
+              'w-20 h-20 flex items-center justify-center rounded-2xl transition-all duration-200 ease-out',
+              'backdrop-blur-sm border',
+              isSelected
+                ? 'bg-white/95 dark:bg-gray-800/95 border-blue-500 dark:border-blue-400 shadow-lg scale-105'
+                : 'bg-white/80 dark:bg-gray-800/80 border-gray-200/50 dark:border-gray-700/50 hover:bg-white/90 dark:hover:bg-gray-800/90 hover:border-gray-300 dark:hover:border-gray-600 hover:shadow-md hover:scale-105',
+            ]"
+          >
+            <img
+              v-if="icon"
+              :src="icon"
+              :alt="label"
+              class="w-14 h-14 object-contain transition-transform duration-200"
+              :class="{ 'scale-110': isSelected }"
+            />
+            <UIcon
+              v-else
+              name="i-heroicons-puzzle-piece-solid"
+              :class="[
+                'w-14 h-14 transition-all duration-200',
+                isSelected
+                  ? 'text-blue-500 dark:text-blue-400 scale-110'
+                  : 'text-gray-400 dark:text-gray-500 group-hover:text-gray-500 dark:group-hover:text-gray-400',
+              ]"
+            />
+          </div>
+          <span
+            :class="[
+              'text-xs text-center max-w-24 truncate px-3 py-1.5 rounded-lg transition-all duration-200',
+              'backdrop-blur-sm',
+              isSelected
+                ? 'bg-white/95 dark:bg-gray-800/95 text-gray-900 dark:text-gray-100 font-medium shadow-md'
+                : 'bg-white/70 dark:bg-gray-800/70 text-gray-700 dark:text-gray-300 group-hover:bg-white/85 dark:group-hover:bg-gray-800/85',
+            ]"
+          >
+            {{ label }}
+          </span>
+        </div>
+      </div>
+    </UContextMenu>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = defineProps<{
+  id: string
+  itemType: DesktopItemType
+  referenceId: string
+  initialX: number
+  initialY: number
+  label: string
+  icon?: string
+}>()
+
+const emit = defineEmits<{
+  positionChanged: [id: string, x: number, y: number]
+  dragStart: [id: string, itemType: string, referenceId: string]
+  dragEnd: []
+}>()
+
+const desktopStore = useDesktopStore()
+const showUninstallDialog = ref(false)
+const { t } = useI18n()
+
+const isSelected = computed(() => desktopStore.isItemSelected(props.id))
+
+const handleClick = (e: MouseEvent) => {
+  // Prevent selection during drag
+  if (isDragging.value) return
+
+  desktopStore.toggleSelection(props.id, e.ctrlKey || e.metaKey)
+}
+
+const handleUninstallClick = () => {
+  showUninstallDialog.value = true
+}
+
+const handleConfirmUninstall = async () => {
+  showUninstallDialog.value = false
+  await desktopStore.uninstallDesktopItem(
+    props.id,
+    props.itemType,
+    props.referenceId,
+  )
+}
+
+const contextMenuItems = computed(() =>
+  desktopStore.getContextMenuItems(
+    props.id,
+    props.itemType,
+    props.referenceId,
+    handleUninstallClick,
+  ),
+)
+
+// Inject viewport size from parent desktop
+const viewportSize = inject<{
+  width: Ref<number>
+  height: Ref<number>
+}>('viewportSize')
+
+const draggableEl = ref<HTMLElement>()
+const x = ref(props.initialX)
+const y = ref(props.initialY)
+const isDragging = ref(false)
+const offsetX = ref(0)
+const offsetY = ref(0)
+
+// Icon dimensions (approximate)
+const iconWidth = 120 // Matches design in template
+const iconHeight = 140
+
+const style = computed(() => ({
+  position: 'absolute' as const,
+  left: `${x.value}px`,
+  top: `${y.value}px`,
+  touchAction: 'none' as const,
+}))
+
+const handlePointerDown = (e: PointerEvent) => {
+  if (!draggableEl.value || !draggableEl.value.parentElement) return
+
+  isDragging.value = true
+  emit('dragStart', props.id, props.itemType, props.referenceId)
+
+  // Get parent offset to convert from viewport coordinates to parent-relative coordinates
+  const parentRect = draggableEl.value.parentElement.getBoundingClientRect()
+
+  // Calculate offset from mouse position to current element position (in parent coordinates)
+  offsetX.value = e.clientX - parentRect.left - x.value
+  offsetY.value = e.clientY - parentRect.top - y.value
+
+  draggableEl.value.setPointerCapture(e.pointerId)
+}
+
+const handlePointerMove = (e: PointerEvent) => {
+  if (!isDragging.value || !draggableEl.value?.parentElement) return
+
+  const parentRect = draggableEl.value.parentElement.getBoundingClientRect()
+  const newX = e.clientX - parentRect.left - offsetX.value
+  const newY = e.clientY - parentRect.top - offsetY.value
+
+  x.value = newX
+  y.value = newY
+}
+
+const handlePointerUp = (e: PointerEvent) => {
+  if (!isDragging.value) return
+
+  isDragging.value = false
+  if (draggableEl.value) {
+    draggableEl.value.releasePointerCapture(e.pointerId)
+  }
+
+  // Snap icon to viewport bounds if outside
+  if (viewportSize) {
+    const maxX = Math.max(0, viewportSize.width.value - iconWidth)
+    const maxY = Math.max(0, viewportSize.height.value - iconHeight)
+    x.value = Math.max(0, Math.min(maxX, x.value))
+    y.value = Math.max(0, Math.min(maxY, y.value))
+  }
+
+  emit('dragEnd')
+  emit('positionChanged', props.id, x.value, y.value)
+}
+
+const handleDoubleClick = () => {
+  // Get icon position and size for animation
+  if (draggableEl.value) {
+    const rect = draggableEl.value.getBoundingClientRect()
+    const sourcePosition = {
+      x: rect.left,
+      y: rect.top,
+      width: rect.width,
+      height: rect.height,
+    }
+    desktopStore.openDesktopItem(
+      props.itemType,
+      props.referenceId,
+      sourcePosition,
+    )
+  } else {
+    desktopStore.openDesktopItem(props.itemType, props.referenceId)
+  }
+}
+</script>
+
+<i18n lang="yaml">
+de:
+  confirmUninstall:
+    title: Erweiterung deinstallieren
+    message: Möchten Sie die Erweiterung '{name}' wirklich deinstallieren? Diese Aktion kann nicht rückgängig gemacht werden.
+    confirm: Deinstallieren
+    cancel: Abbrechen
+
+en:
+  confirmUninstall:
+    title: Uninstall Extension
+    message: Do you really want to uninstall the extension '{name}'? This action cannot be undone.
+    confirm: Uninstall
+    cancel: Cancel
+</i18n>

src/components/haex/desktop/index.vue

@@ -0,0 +1,701 @@
+<template>
+  <div
+    ref="desktopEl"
+    class="absolute inset-0 overflow-hidden"
+  >
+    <Swiper
+      :modules="[SwiperNavigation]"
+      :slides-per-view="1"
+      :space-between="0"
+      :initial-slide="currentWorkspaceIndex"
+      :speed="300"
+      :touch-angle="45"
+      :no-swiping="true"
+      no-swiping-class="no-swipe"
+      :allow-touch-move="allowSwipe"
+      class="h-full w-full"
+      direction="vertical"
+      @swiper="onSwiperInit"
+      @slide-change="onSlideChange"
+    >
+      <SwiperSlide
+        v-for="workspace in workspaces"
+        :key="workspace.id"
+        class="w-full h-full"
+      >
+        <div
+          class="w-full h-full relative"
+          @click.self.stop="handleDesktopClick"
+          @mousedown.left.self="handleAreaSelectStart"
+          @dragover.prevent="handleDragOver"
+          @drop.prevent="handleDrop($event, workspace.id)"
+        >
+          <!-- Grid Pattern Background -->
+          <div
+            class="absolute inset-0 pointer-events-none opacity-30"
+            :style="{
+              backgroundImage:
+                'linear-gradient(rgba(0, 0, 0, 0.1) 1px, transparent 1px), linear-gradient(90deg, rgba(0, 0, 0, 0.1) 1px, transparent 1px)',
+              backgroundSize: '32px 32px',
+            }"
+          />
+
+          <!-- Snap Dropzones (only visible when window drag near edge) -->
+
+          <div
+            class="absolute left-0 top-0 bottom-0 border-blue-500 pointer-events-none backdrop-blur-sm z-50 transition-all duration-500 ease-in-out"
+            :class="showLeftSnapZone ? 'w-1/2 bg-blue-500/20 border-2' : 'w-0'"
+          />
+
+          <div
+            class="absolute right-0 top-0 bottom-0 border-blue-500 pointer-events-none backdrop-blur-sm z-50 transition-all duration-500 ease-in-out"
+            :class="showRightSnapZone ? 'w-1/2 bg-blue-500/20 border-2' : 'w-0'"
+          />
+
+          <!-- Area Selection Box -->
+          <div
+            v-if="isAreaSelecting"
+            class="absolute bg-blue-500/20 border-2 border-blue-500 pointer-events-none z-30"
+            :style="selectionBoxStyle"
+          />
+
+          <!-- Icons for this workspace -->
+          <HaexDesktopIcon
+            v-for="item in getWorkspaceIcons(workspace.id)"
+            :id="item.id"
+            :key="item.id"
+            :item-type="item.itemType"
+            :reference-id="item.referenceId"
+            :initial-x="item.positionX"
+            :initial-y="item.positionY"
+            :label="item.label"
+            :icon="item.icon"
+            class="no-swipe"
+            @position-changed="handlePositionChanged"
+            @drag-start="handleDragStart"
+            @drag-end="handleDragEnd"
+          />
+
+          <!-- Windows for this workspace -->
+          <template
+            v-for="window in getWorkspaceWindows(workspace.id)"
+            :key="window.id"
+          >
+            <!-- Overview Mode: Teleport to window preview -->
+            <Teleport
+              v-if="
+                windowManager.showWindowOverview &&
+                overviewWindowState.has(window.id)
+              "
+              :to="`#window-preview-${window.id}`"
+            >
+              <div
+                class="absolute origin-top-left"
+                :style="{
+                  transform: `scale(${overviewWindowState.get(window.id)!.scale})`,
+                  width: `${overviewWindowState.get(window.id)!.width}px`,
+                  height: `${overviewWindowState.get(window.id)!.height}px`,
+                }"
+              >
+                <HaexWindow
+                  v-show="
+                    windowManager.showWindowOverview || !window.isMinimized
+                  "
+                  :id="window.id"
+                  v-model:x="overviewWindowState.get(window.id)!.x"
+                  v-model:y="overviewWindowState.get(window.id)!.y"
+                  v-model:width="overviewWindowState.get(window.id)!.width"
+                  v-model:height="overviewWindowState.get(window.id)!.height"
+                  :title="window.title"
+                  :icon="window.icon"
+                  :is-active="windowManager.isWindowActive(window.id)"
+                  :source-x="window.sourceX"
+                  :source-y="window.sourceY"
+                  :source-width="window.sourceWidth"
+                  :source-height="window.sourceHeight"
+                  :is-opening="window.isOpening"
+                  :is-closing="window.isClosing"
+                  :warning-level="
+                    window.type === 'extension' &&
+                    availableExtensions.find(
+                      (ext) => ext.id === window.sourceId,
+                    )?.devServerUrl
+                      ? 'warning'
+                      : undefined
+                  "
+                  class="no-swipe"
+                  @close="windowManager.closeWindow(window.id)"
+                  @minimize="windowManager.minimizeWindow(window.id)"
+                  @activate="windowManager.activateWindow(window.id)"
+                  @position-changed="
+                    (x, y) =>
+                      windowManager.updateWindowPosition(window.id, x, y)
+                  "
+                  @size-changed="
+                    (width, height) =>
+                      windowManager.updateWindowSize(window.id, width, height)
+                  "
+                  @drag-start="handleWindowDragStart(window.id)"
+                  @drag-end="handleWindowDragEnd"
+                >
+                  <!-- System Window: Render Vue Component -->
+                  <component
+                    :is="getSystemWindowComponent(window.sourceId)"
+                    v-if="window.type === 'system'"
+                  />
+
+                  <!-- Extension Window: Render iFrame -->
+                  <HaexDesktopExtensionFrame
+                    v-else
+                    :extension-id="window.sourceId"
+                    :window-id="window.id"
+                  />
+                </HaexWindow>
+              </div>
+            </Teleport>
+
+            <!-- Desktop Mode: Render directly in workspace -->
+            <HaexWindow
+              v-else
+              v-show="windowManager.showWindowOverview || !window.isMinimized"
+              :id="window.id"
+              v-model:x="window.x"
+              v-model:y="window.y"
+              v-model:width="window.width"
+              v-model:height="window.height"
+              :title="window.title"
+              :icon="window.icon"
+              :is-active="windowManager.isWindowActive(window.id)"
+              :source-x="window.sourceX"
+              :source-y="window.sourceY"
+              :source-width="window.sourceWidth"
+              :source-height="window.sourceHeight"
+              :is-opening="window.isOpening"
+              :is-closing="window.isClosing"
+              :warning-level="
+                window.type === 'extension' &&
+                availableExtensions.find((ext) => ext.id === window.sourceId)
+                  ?.devServerUrl
+                  ? 'warning'
+                  : undefined
+              "
+              class="no-swipe"
+              @close="windowManager.closeWindow(window.id)"
+              @minimize="windowManager.minimizeWindow(window.id)"
+              @activate="windowManager.activateWindow(window.id)"
+              @position-changed="
+                (x, y) => windowManager.updateWindowPosition(window.id, x, y)
+              "
+              @size-changed="
+                (width, height) =>
+                  windowManager.updateWindowSize(window.id, width, height)
+              "
+              @drag-start="handleWindowDragStart(window.id)"
+              @drag-end="handleWindowDragEnd"
+            >
+              <!-- System Window: Render Vue Component -->
+              <component
+                :is="getSystemWindowComponent(window.sourceId)"
+                v-if="window.type === 'system'"
+              />
+
+              <!-- Extension Window: Render iFrame -->
+              <HaexDesktopExtensionFrame
+                v-else
+                :extension-id="window.sourceId"
+                :window-id="window.id"
+              />
+            </HaexWindow>
+          </template>
+        </div>
+      </SwiperSlide>
+    </Swiper>
+
+    <!-- Window Overview Modal -->
+    <HaexWindowOverview />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { Swiper, SwiperSlide } from 'swiper/vue'
+import { Navigation } from 'swiper/modules'
+import type { Swiper as SwiperType } from 'swiper'
+import 'swiper/css'
+import 'swiper/css/navigation'
+
+const SwiperNavigation = Navigation
+
+const desktopStore = useDesktopStore()
+const extensionsStore = useExtensionsStore()
+const windowManager = useWindowManagerStore()
+const workspaceStore = useWorkspaceStore()
+const { desktopItems } = storeToRefs(desktopStore)
+const { availableExtensions } = storeToRefs(extensionsStore)
+const {
+  currentWorkspace,
+  currentWorkspaceIndex,
+  workspaces,
+  swiperInstance,
+  allowSwipe,
+  isOverviewMode,
+} = storeToRefs(workspaceStore)
+
+const { x: mouseX } = useMouse()
+
+const desktopEl = useTemplateRef('desktopEl')
+
+// Track desktop viewport size reactively
+const { width: viewportWidth, height: viewportHeight } =
+  useElementSize(desktopEl)
+
+// Provide viewport size to child windows
+provide('viewportSize', {
+  width: viewportWidth,
+  height: viewportHeight,
+})
+
+// Area selection state
+const isAreaSelecting = ref(false)
+const selectionStart = ref({ x: 0, y: 0 })
+const selectionEnd = ref({ x: 0, y: 0 })
+
+const selectionBoxStyle = computed(() => {
+  const x1 = Math.min(selectionStart.value.x, selectionEnd.value.x)
+  const y1 = Math.min(selectionStart.value.y, selectionEnd.value.y)
+  const x2 = Math.max(selectionStart.value.x, selectionEnd.value.x)
+  const y2 = Math.max(selectionStart.value.y, selectionEnd.value.y)
+
+  return {
+    left: `${x1}px`,
+    top: `${y1}px`,
+    width: `${x2 - x1}px`,
+    height: `${y2 - y1}px`,
+  }
+})
+
+// Drag state for desktop icons
+const isDragging = ref(false)
+const currentDraggedItemId = ref<string>()
+const currentDraggedItemType = ref<string>()
+const currentDraggedReferenceId = ref<string>()
+
+// Window drag state for snap zones
+const isWindowDragging = ref(false)
+const snapEdgeThreshold = 50 // pixels from edge to show snap zone
+
+// Computed visibility for snap zones (uses mouseX from above)
+const showLeftSnapZone = computed(() => {
+  return isWindowDragging.value && mouseX.value <= snapEdgeThreshold
+})
+
+const showRightSnapZone = computed(() => {
+  if (!isWindowDragging.value) return false
+  const viewportWidth = window.innerWidth
+  return mouseX.value >= viewportWidth - snapEdgeThreshold
+})
+
+// Get icons for a specific workspace
+const getWorkspaceIcons = (workspaceId: string) => {
+  return desktopItems.value
+    .filter((item) => item.workspaceId === workspaceId)
+    .map((item) => {
+      if (item.itemType === 'system') {
+        const systemWindow = windowManager
+          .getAllSystemWindows()
+          .find((win) => win.id === item.referenceId)
+
+        return {
+          ...item,
+          label: systemWindow?.name || 'Unknown',
+          icon: systemWindow?.icon || '',
+        }
+      }
+
+      if (item.itemType === 'extension') {
+        const extension = availableExtensions.value.find(
+          (ext) => ext.id === item.referenceId,
+        )
+
+        console.log('found ext', extension)
+        return {
+          ...item,
+          label: extension?.name || 'Unknown',
+          icon: extension?.icon || '',
+        }
+      }
+
+      if (item.itemType === 'file') {
+        // Für später: file handling
+        return {
+          ...item,
+          label: item.referenceId,
+          icon: undefined,
+        }
+      }
+
+      if (item.itemType === 'folder') {
+        // Für später: folder handling
+        return {
+          ...item,
+          label: item.referenceId,
+          icon: undefined,
+        }
+      }
+
+      return {
+        ...item,
+        label: item.referenceId,
+        icon: undefined,
+      }
+    })
+}
+
+// Get windows for a specific workspace (including minimized for teleport)
+const getWorkspaceWindows = (workspaceId: string) => {
+  return windowManager.windows.filter((w) => w.workspaceId === workspaceId)
+}
+
+// Get Vue Component for system window
+const getSystemWindowComponent = (sourceId: string) => {
+  const systemWindow = windowManager.getSystemWindow(sourceId)
+  return systemWindow?.component
+}
+
+const handlePositionChanged = async (id: string, x: number, y: number) => {
+  try {
+    await desktopStore.updateDesktopItemPositionAsync(id, x, y)
+  } catch (error) {
+    console.error('Fehler beim Speichern der Position:', error)
+  }
+}
+
+const handleDragStart = (id: string, itemType: string, referenceId: string) => {
+  isDragging.value = true
+  currentDraggedItemId.value = id
+  currentDraggedItemType.value = itemType
+  currentDraggedReferenceId.value = referenceId
+  allowSwipe.value = false // Disable Swiper during icon drag
+}
+
+const handleDragEnd = async () => {
+  // Cleanup drag state
+  isDragging.value = false
+  currentDraggedItemId.value = undefined
+  currentDraggedItemType.value = undefined
+  currentDraggedReferenceId.value = undefined
+  allowSwipe.value = true // Re-enable Swiper after drag
+}
+
+// Handle drag over for launcher items
+const handleDragOver = (event: DragEvent) => {
+  if (!event.dataTransfer) return
+
+  // Check if this is a launcher item
+  if (event.dataTransfer.types.includes('application/haex-launcher-item')) {
+    event.dataTransfer.dropEffect = 'copy'
+  }
+}
+
+// Handle drop for launcher items
+const handleDrop = async (event: DragEvent, workspaceId: string) => {
+  if (!event.dataTransfer) return
+
+  const launcherItemData = event.dataTransfer.getData(
+    'application/haex-launcher-item',
+  )
+  if (!launcherItemData) return
+
+  try {
+    const item = JSON.parse(launcherItemData) as {
+      id: string
+      name: string
+      icon: string
+      type: 'system' | 'extension'
+    }
+
+    // Get drop position relative to desktop
+    const desktopRect = (
+      event.currentTarget as HTMLElement
+    ).getBoundingClientRect()
+    const x = Math.max(0, event.clientX - desktopRect.left - 32) // Center icon (64px / 2)
+    const y = Math.max(0, event.clientY - desktopRect.top - 32)
+
+    // Create desktop icon on the specific workspace
+    await desktopStore.addDesktopItemAsync(
+      item.type as DesktopItemType,
+      item.id,
+      x,
+      y,
+      workspaceId,
+    )
+  } catch (error) {
+    console.error('Failed to create desktop icon:', error)
+  }
+}
+
+const handleDesktopClick = () => {
+  // Only clear selection if it was a simple click, not an area selection
+  // Check if we just finished an area selection (box size > threshold)
+  const boxWidth = Math.abs(selectionEnd.value.x - selectionStart.value.x)
+  const boxHeight = Math.abs(selectionEnd.value.y - selectionStart.value.y)
+
+  // If box is larger than 5px in any direction, it was an area select, not a click
+  if (boxWidth > 5 || boxHeight > 5) {
+    return
+  }
+
+  desktopStore.clearSelection()
+  isOverviewMode.value = false
+}
+
+const handleWindowDragStart = (windowId: string) => {
+  console.log('[Desktop] handleWindowDragStart:', windowId)
+  isWindowDragging.value = true
+  windowManager.draggingWindowId = windowId // Set in store for workspace cards
+  console.log(
+    '[Desktop] draggingWindowId set to:',
+    windowManager.draggingWindowId,
+  )
+  allowSwipe.value = false // Disable Swiper during window drag
+}
+
+const handleWindowDragEnd = async () => {
+  console.log('[Desktop] handleWindowDragEnd')
+
+  // Check if window should snap to left or right
+  const draggingWindowId = windowManager.draggingWindowId
+
+  if (draggingWindowId) {
+    if (showLeftSnapZone.value) {
+      // Snap to left half
+      windowManager.updateWindowPosition(draggingWindowId, 0, 0)
+      windowManager.updateWindowSize(
+        draggingWindowId,
+        viewportWidth.value / 2,
+        viewportHeight.value,
+      )
+    } else if (showRightSnapZone.value) {
+      // Snap to right half
+      windowManager.updateWindowPosition(
+        draggingWindowId,
+        viewportWidth.value / 2,
+        0,
+      )
+      windowManager.updateWindowSize(
+        draggingWindowId,
+        viewportWidth.value / 2,
+        viewportHeight.value,
+      )
+    }
+  }
+
+  isWindowDragging.value = false
+  windowManager.draggingWindowId = null // Clear from store
+  allowSwipe.value = true // Re-enable Swiper after drag
+}
+
+// Area selection handlers
+const handleAreaSelectStart = (e: MouseEvent) => {
+  if (!desktopEl.value) return
+
+  const rect = desktopEl.value.getBoundingClientRect()
+  const x = e.clientX - rect.left
+  const y = e.clientY - rect.top
+
+  isAreaSelecting.value = true
+  selectionStart.value = { x, y }
+  selectionEnd.value = { x, y }
+
+  // Clear current selection
+  desktopStore.clearSelection()
+}
+
+// Track mouse movement for area selection
+useEventListener(window, 'mousemove', (e: MouseEvent) => {
+  if (isAreaSelecting.value && desktopEl.value) {
+    const rect = desktopEl.value.getBoundingClientRect()
+    const x = e.clientX - rect.left
+    const y = e.clientY - rect.top
+
+    selectionEnd.value = { x, y }
+
+    // Find all items within selection box
+    selectItemsInBox()
+  }
+})
+
+// End area selection
+useEventListener(window, 'mouseup', () => {
+  if (isAreaSelecting.value) {
+    isAreaSelecting.value = false
+
+    // Reset selection coordinates after a short delay
+    // This allows handleDesktopClick to still check the box size
+    setTimeout(() => {
+      selectionStart.value = { x: 0, y: 0 }
+      selectionEnd.value = { x: 0, y: 0 }
+    }, 100)
+  }
+})
+
+const selectItemsInBox = () => {
+  const x1 = Math.min(selectionStart.value.x, selectionEnd.value.x)
+  const y1 = Math.min(selectionStart.value.y, selectionEnd.value.y)
+  const x2 = Math.max(selectionStart.value.x, selectionEnd.value.x)
+  const y2 = Math.max(selectionStart.value.y, selectionEnd.value.y)
+
+  desktopStore.clearSelection()
+
+  desktopItems.value.forEach((item) => {
+    // Check if item position is within selection box
+    const itemX = item.positionX + 60 // Icon center (approx)
+    const itemY = item.positionY + 60
+
+    if (itemX >= x1 && itemX <= x2 && itemY >= y1 && itemY <= y2) {
+      desktopStore.toggleSelection(item.id, true) // true = add to selection
+    }
+  })
+}
+
+// Swiper event handlers
+const onSwiperInit = (swiper: SwiperType) => {
+  swiperInstance.value = swiper
+}
+
+const onSlideChange = (swiper: SwiperType) => {
+  workspaceStore.switchToWorkspace(
+    workspaceStore.workspaces.at(swiper.activeIndex)?.id,
+  )
+}
+
+/* const handleRemoveWorkspace = async () => {
+  if (!currentWorkspace.value || workspaces.value.length <= 1) return
+
+  const currentIndex = currentWorkspaceIndex.value
+  await workspaceStore.removeWorkspaceAsync(currentWorkspace.value.id)
+
+  // Slide to adjusted index
+  nextTick(() => {
+    if (swiperInstance.value) {
+      const newIndex = Math.min(currentIndex, workspaces.value.length - 1)
+      swiperInstance.value.slideTo(newIndex)
+    }
+  })
+}
+
+const handleDropWindowOnWorkspace = async (
+  event: DragEvent,
+  targetWorkspaceId: string,
+) => {
+  // Get the window ID from drag data (will be set when we implement window dragging)
+  const windowId = event.dataTransfer?.getData('windowId')
+  if (windowId) {
+    await moveWindowToWorkspace(windowId, targetWorkspaceId)
+  }
+} */
+
+// Overview Mode: Calculate grid positions and scale for windows
+// Calculate preview dimensions for window overview
+const MIN_PREVIEW_WIDTH = 300 // 50% increase from 200
+const MAX_PREVIEW_WIDTH = 600 // 50% increase from 400
+const MIN_PREVIEW_HEIGHT = 225 // 50% increase from 150
+const MAX_PREVIEW_HEIGHT = 450 // 50% increase from 300
+
+// Store window state for overview (position only, size stays original)
+const overviewWindowState = ref(
+  new Map<
+    string,
+    { x: number; y: number; width: number; height: number; scale: number }
+  >(),
+)
+
+// Calculate scale and card dimensions for each window
+watch(
+  () => windowManager.showWindowOverview,
+  (isOpen) => {
+    if (isOpen) {
+      // Wait for the Overview modal to mount and create the teleport targets
+      nextTick(() => {
+        windowManager.windows.forEach((window) => {
+          const scaleX = MAX_PREVIEW_WIDTH / window.width
+          const scaleY = MAX_PREVIEW_HEIGHT / window.height
+          const scale = Math.min(scaleX, scaleY, 1)
+
+          // Ensure minimum card size
+          const scaledWidth = window.width * scale
+          const scaledHeight = window.height * scale
+
+          let finalScale = scale
+          if (scaledWidth < MIN_PREVIEW_WIDTH) {
+            finalScale = MIN_PREVIEW_WIDTH / window.width
+          }
+          if (scaledHeight < MIN_PREVIEW_HEIGHT) {
+            finalScale = Math.max(
+              finalScale,
+              MIN_PREVIEW_HEIGHT / window.height,
+            )
+          }
+
+          overviewWindowState.value.set(window.id, {
+            x: 0,
+            y: 0,
+            width: window.width,
+            height: window.height,
+            scale: finalScale,
+          })
+        })
+      })
+    } else {
+      // Clear state when overview is closed
+      overviewWindowState.value.clear()
+    }
+  },
+)
+
+// Disable Swiper in overview mode
+watch(isOverviewMode, (newValue) => {
+  allowSwipe.value = !newValue
+})
+
+// Watch for workspace changes to reload desktop items
+watch(currentWorkspace, async () => {
+  if (currentWorkspace.value) {
+    await desktopStore.loadDesktopItemsAsync()
+  }
+})
+
+onMounted(async () => {
+  // Load workspaces first
+  await workspaceStore.loadWorkspacesAsync()
+
+  // Then load desktop items for current workspace
+  await desktopStore.loadDesktopItemsAsync()
+})
+</script>
+
+<style scoped>
+.slide-down-enter-active,
+.slide-down-leave-active {
+  transition: all 0.3s ease;
+}
+
+.slide-down-enter-from {
+  opacity: 0;
+  transform: translateY(-100%);
+}
+
+.slide-down-leave-to {
+  opacity: 0;
+  transform: translateY(-100%);
+}
+
+.fade-enter-active,
+.fade-leave-active {
+  transition: opacity 0.2s ease;
+}
+
+.fade-enter-from,
+.fade-leave-to {
+  opacity: 0;
+}
+</style>

src/components/haex/extension/card.vue

@@ -89,7 +89,11 @@ const removeExtensionAsync = async () => {
   }
 
   try {
-    await extensionStore.removeExtensionAsync(extension.id, extension.version)
+    await extensionStore.removeExtensionAsync(
+      extension.publicKey,
+      extension.name,
+      extension.version,
+    )
     await extensionStore.loadExtensionsAsync()
 
     add({

src/components/haex/extension/dialog/install.vue

@@ -5,166 +5,268 @@
     @confirm="onConfirm"
   >
     <template #title>
-      <i18n-t
+      {{ t('title') }}
-        keypath="question"
-        tag="p"
-      >
-        <template #extension>
-          <span class="font-bold text-primary">{{ manifest?.name }}</span>
-        </template>
-      </i18n-t>
     </template>
 
-    <div class="flex flex-col">
+    <template #body>
-      <nav
+      <div class="flex flex-col gap-6">
-        class="tabs tabs-bordered"
+        <!-- Extension Info -->
-        aria-label="Tabs"
+        <UCard>
-        role="tablist"
+          <div class="flex items-start gap-4">
-        aria-orientation="horizontal"
+            <div
-      >
+              v-if="preview?.manifest.icon"
-        <button
+              class="w-16 h-16 shrink-0"
-          v-show="manifest?.permissions?.database"
+            >
-          id="tabs-basic-item-1"
+              <UIcon
-          type="button"
+                :name="preview.manifest.icon"
-          class="tab active-tab:tab-active active"
+                class="w-full h-full"
-          data-tab="#tabs-basic-1"
+              />
-          aria-controls="tabs-basic-1"
+            </div>
-          role="tab"
+            <div class="flex-1">
-          aria-selected="true"
+              <h3 class="text-xl font-bold">
-        >
+                {{ preview?.manifest.name }}
-          {{ t('database') }}
+              </h3>
-        </button>
+              <p class="text-sm text-gray-500 dark:text-gray-400">
-        <button
+                {{ t('version') }}: {{ preview?.manifest.version }}
-          v-show="manifest?.permissions?.filesystem"
+              </p>
-          id="tabs-basic-item-2"
+              <p
-          type="button"
+                v-if="preview?.manifest.author"
-          class="tab active-tab:tab-active"
+                class="text-sm text-gray-500 dark:text-gray-400"
-          data-tab="#tabs-basic-2"
+              >
-          aria-controls="tabs-basic-2"
+                {{ t('author') }}: {{ preview.manifest.author }}
-          role="tab"
+              </p>
-          aria-selected="false"
+              <p
-        >
+                v-if="preview?.manifest.description"
-          {{ t('filesystem') }}
+                class="text-sm mt-2"
-        </button>
+              >
-        <button
+                {{ preview.manifest.description }}
-          v-show="manifest?.permissions?.http"
+              </p>
-          id="tabs-basic-item-3"
-          type="button"
-          class="tab active-tab:tab-active"
-          data-tab="#tabs-basic-3"
-          aria-controls="tabs-basic-3"
-          role="tab"
-          aria-selected="false"
-        >
-          {{ t('http') }}
-        </button>
-      </nav>
 
-      <div class="mt-3 min-h-40">
+              <!-- Signature Verification -->
-        <div
+              <UBadge
-          id="tabs-basic-1"
+                :color="preview?.is_valid_signature ? 'success' : 'error'"
-          role="tabpanel"
+                variant="subtle"
-          aria-labelledby="tabs-basic-item-1"
+                class="mt-2"
-        >
+              >
-          <HaexExtensionManifestPermissionsDatabase
+                <template #leading>
-            :database="permissions?.database"
+                  <UIcon
-          />
+                    :name="
-        </div>
+                      preview?.is_valid_signature
-        <div
+                        ? 'i-heroicons-shield-check'
-          id="tabs-basic-2"
+                        : 'i-heroicons-shield-exclamation'
-          class="hidden"
+                    "
-          role="tabpanel"
+                  />
-          aria-labelledby="tabs-basic-item-2"
+                </template>
-        >
+                {{
-          <HaexExtensionManifestPermissionsFilesystem
+                  preview?.is_valid_signature
-            :filesystem="permissions?.filesystem"
+                    ? t('signature.valid')
-          />
+                    : t('signature.invalid')
-        </div>
+                }}
-        <div
+              </UBadge>
-          id="tabs-basic-3"
+            </div>
-          class="hidden"
+          </div>
-          role="tabpanel"
+        </UCard>
-          aria-labelledby="tabs-basic-item-3"
+
-        >
+        <!-- Add to Desktop Option -->
-          <HaexExtensionManifestPermissionsHttp :http="permissions?.http" />
+        <UCheckbox
+          v-model="addToDesktop"
+          :label="t('addToDesktop')"
+        />
+
+        <!-- Permissions Section -->
+        <div class="flex flex-col gap-4">
+          <h4 class="text-lg font-semibold">
+            {{ t('permissions.title') }}
+          </h4>
+
+          <UAccordion
+            :items="permissionAccordionItems"
+            :ui="{ root: 'flex flex-col gap-2' }"
+          >
+            <template #database>
+              <div
+                v-if="databasePermissions"
+                class="pb-4"
+              >
+                <HaexExtensionPermissionList
+                  v-model="databasePermissions"
+                  :title="t('permissions.database')"
+                />
+              </div>
+            </template>
+
+            <template #filesystem>
+              <div
+                v-if="filesystemPermissions"
+                class="pb-4"
+              >
+                <HaexExtensionPermissionList
+                  v-model="filesystemPermissions"
+                  :title="t('permissions.filesystem')"
+                />
+              </div>
+            </template>
+
+            <template #http>
+              <div
+                v-if="httpPermissions"
+                class="pb-4"
+              >
+                <HaexExtensionPermissionList
+                  v-model="httpPermissions"
+                  :title="t('permissions.http')"
+                />
+              </div>
+            </template>
+
+            <template #shell>
+              <div
+                v-if="shellPermissions"
+                class="pb-4"
+              >
+                <HaexExtensionPermissionList
+                  v-model="shellPermissions"
+                  :title="t('permissions.shell')"
+                />
+              </div>
+            </template>
+          </UAccordion>
         </div>
       </div>
-    </div>
+    </template>
   </UiDialogConfirm>
 </template>
 
 <script setup lang="ts">
-import type { IHaexHubExtensionManifest } from '~/types/haexhub'
+import type { ExtensionPreview } from '~~/src-tauri/bindings/ExtensionPreview'
 
 const { t } = useI18n()
 
 const open = defineModel<boolean>('open', { default: false })
-const { manifest } = defineProps<{
+const preview = defineModel<ExtensionPreview | null>('preview', {
-  manifest?: IHaexHubExtensionManifest | null
+  default: null,
+})
+const addToDesktop = ref(true)
+
+const databasePermissions = computed({
+  get: () => preview.value?.editable_permissions?.database || [],
+  set: (value) => {
+    if (preview.value?.editable_permissions) {
+      preview.value.editable_permissions.database = value
+    }
+  },
+})
+
+const filesystemPermissions = computed({
+  get: () => preview.value?.editable_permissions?.filesystem || [],
+  set: (value) => {
+    if (preview.value?.editable_permissions) {
+      preview.value.editable_permissions.filesystem = value
+    }
+  },
+})
+
+const httpPermissions = computed({
+  get: () => preview.value?.editable_permissions?.http || [],
+  set: (value) => {
+    if (preview.value?.editable_permissions) {
+      preview.value.editable_permissions.http = value
+    }
+  },
+})
+
+const shellPermissions = computed({
+  get: () => preview.value?.editable_permissions?.shell || [],
+  set: (value) => {
+    if (preview.value?.editable_permissions) {
+      preview.value.editable_permissions.shell = value
+    }
+  },
+})
+
+const permissionAccordionItems = computed(() => {
+  const items = []
+
+  if (databasePermissions.value?.length) {
+    items.push({
+      label: t('permissions.database'),
+      icon: 'i-heroicons-circle-stack',
+      slot: 'database',
+      defaultOpen: true,
+    })
+  }
+
+  if (filesystemPermissions.value?.length) {
+    items.push({
+      label: t('permissions.filesystem'),
+      icon: 'i-heroicons-folder',
+      slot: 'filesystem',
+    })
+  }
+
+  if (httpPermissions.value?.length) {
+    items.push({
+      label: t('permissions.http'),
+      icon: 'i-heroicons-globe-alt',
+      slot: 'http',
+    })
+  }
+
+  if (shellPermissions.value?.length) {
+    items.push({
+      label: t('permissions.shell'),
+      icon: 'i-heroicons-command-line',
+      slot: 'shell',
+    })
+  }
+
+  return items
+})
+
+const emit = defineEmits<{
+  deny: []
+  confirm: [addToDesktop: boolean]
 }>()
 
-const permissions = computed(() => ({
-  database: {
-    read: manifest?.permissions.database?.read?.map((read) => ({
-      [read]: true,
-    })),
-    write: manifest?.permissions.database?.read?.map((write) => ({
-      [write]: true,
-    })),
-    create: manifest?.permissions.database?.read?.map((create) => ({
-      [create]: true,
-    })),
-  },
-
-  filesystem: {
-    read: manifest?.permissions.filesystem?.read?.map((read) => ({
-      [read]: true,
-    })),
-    write: manifest?.permissions.filesystem?.write?.map((write) => ({
-      [write]: true,
-    })),
-  },
-
-  http: manifest?.permissions.http?.map((http) => ({
-    [http]: true,
-  })),
-}))
-
-watch(permissions, () => console.log('permissions', permissions.value))
-const emit = defineEmits(['deny', 'confirm'])
-
 const onDeny = () => {
   open.value = false
-  console.log('onDeny open', open.value)
   emit('deny')
 }
 
 const onConfirm = () => {
   open.value = false
-  console.log('onConfirm open', open.value)
+  emit('confirm', addToDesktop.value)
-  emit('confirm')
 }
 </script>
 
-<i18n lang="json">
+<i18n lang="yaml">
-{
+de:
-  "de": {
+  title: Erweiterung installieren
-    "title": "Erweiterung hinzufügen",
+  version: Version
-    "question": "Erweiterung {extension} hinzufügen?",
+  author: Autor
-    "confirm": "Bestätigen",
+  addToDesktop: Zum Desktop hinzufügen
-    "deny": "Ablehnen",
+  signature:
-    "database": "Datenbank",
+    valid: Signatur verifiziert
-    "http": "Internet",
+    invalid: Signatur ungültig
-    "filesystem": "Dateisystem"
+  permissions:
-  },
+    title: Berechtigungen
-  "en": {
+    database: Datenbank
-    "title": "Confirm Permission",
+    filesystem: Dateisystem
-    "question": "Add Extension {extension}?",
+    http: Internet
-    "confirm": "Confirm",
+    shell: Terminal
-    "deny": "Deny",
+
-    "database": "Database",
+en:
-    "http": "Internet",
+  title: Install Extension
-    "filesystem": "Filesystem"
+  version: Version
-  }
+  author: Author
-}
+  addToDesktop: Add to Desktop
+  signature:
+    valid: Signature verified
+    invalid: Invalid signature
+  permissions:
+    title: Permissions
+    database: Database
+    filesystem: Filesystem
+    http: Internet
+    shell: Terminal
 </i18n>

src/components/haex/extension/dialog/reinstall.vue

@@ -1,33 +1,87 @@
 <template>
-  <UiDialogConfirm v-model:open="open">
+  <UiDialogConfirm
+    v-model:open="open"
+    @abort="onDeny"
+    @confirm="onConfirm"
+  >
     <template #title>
-      <i18n-t keypath="title" tag="p">
+      {{ t('title', { extensionName: preview?.manifest.name }) }}
-        <template #extensionName>
-          <span class="font-bold text-primary">{{ manifest?.name }}</span>
-        </template>
-      </i18n-t>
     </template>
 
-    <p>{{ t("question", { extensionName: manifest?.name }) }}</p>
+    <template #body>
+      <div class="flex flex-col gap-4">
+        <p>{{ t('question', { extensionName: preview?.manifest.name }) }}</p>
+
+        <UAlert
+          color="warning"
+          variant="soft"
+          :title="t('warning.title')"
+          :description="t('warning.description')"
+          icon="i-heroicons-exclamation-triangle"
+        />
+
+        <div
+          v-if="preview"
+          class="bg-gray-100 dark:bg-gray-800 rounded-lg p-4"
+        >
+          <div class="flex items-center gap-3">
+            <UIcon
+              v-if="preview.manifest.icon"
+              :name="preview.manifest.icon"
+              class="w-12 h-12"
+            />
+            <div class="flex-1">
+              <h4 class="font-semibold">
+                {{ preview.manifest.name }}
+              </h4>
+              <p class="text-sm text-gray-500 dark:text-gray-400">
+                {{ t('version') }}: {{ preview.manifest.version }}
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+    </template>
   </UiDialogConfirm>
 </template>
 
 <script setup lang="ts">
-import type { IHaexHubExtensionManifest } from "~/types/haexhub";
+import type { ExtensionPreview } from '~~/src-tauri/bindings/ExtensionPreview'
 
-const { t } = useI18n();
+const { t } = useI18n()
 
-const open = defineModel<boolean>("open", { default: false });
+const open = defineModel<boolean>('open', { default: false })
-const { manifest } = defineProps<{ manifest?: IHaexHubExtensionManifest | null }>();
+const preview = defineModel<ExtensionPreview | null>('preview', {
+  default: null,
+})
 
+const emit = defineEmits(['deny', 'confirm'])
+
+const onDeny = () => {
+  open.value = false
+  emit('deny')
+}
+
+const onConfirm = () => {
+  open.value = false
+  emit('confirm')
+}
 </script>
 
 <i18n lang="yaml">
-  de:
+de:
-    title: "{extensionName} bereits installiert"
+  title: '{extensionName} bereits installiert'
-    question: Soll die Erweiterung {extensionName} erneut installiert werden?
+  question: Soll die Erweiterung {extensionName} erneut installiert werden?
+  warning:
+    title: Achtung
+    description: Die vorhandene Version wird vollständig entfernt und durch die neue Version ersetzt. Dieser Vorgang kann nicht rückgängig gemacht werden.
+  version: Version
 
-  en:
+en:
-    title: "{extensionName} is already installed"
+  title: '{extensionName} is already installed'
-    question: Do you want to reinstall {extensionName}?
+  question: Do you want to reinstall {extensionName}?
+  warning:
+    title: Warning
+    description: The existing version will be completely removed and replaced with the new version. This action cannot be undone.
+  version: Version
 </i18n>

src/components/haex/extension/dialog/remove.vue

@@ -1,43 +1,106 @@
 <template>
-  <UiDialogConfirm v-model:open="open" :title="t('title')" @confirm="onConfirm">
+  <UiDialogConfirm
-    <div>
+    v-model:open="open"
-      <i18n-t keypath="question" tag="p">
+    @abort="onAbort"
-        <template #name>
+    @confirm="onConfirm"
-          <span class="font-bold text-primary">{{ extension?.name }}</span>
+  >
-        </template>
+    <template #title>
-      </i18n-t>
+      {{ t('title') }}
-    </div>
+    </template>
+
+    <template #body>
+      <div class="flex flex-col gap-4">
+        <i18n-t
+          keypath="question"
+          tag="p"
+        >
+          <template #name>
+            <span class="font-bold text-primary">{{ extension?.name }}</span>
+          </template>
+        </i18n-t>
+
+        <UAlert
+          color="error"
+          variant="soft"
+          :title="t('warning.title')"
+          :description="t('warning.description')"
+          icon="i-heroicons-exclamation-triangle"
+        />
+
+        <div
+          v-if="extension"
+          class="bg-gray-100 dark:bg-gray-800 rounded-lg p-4"
+        >
+          <div class="flex items-center gap-3">
+            <UIcon
+              v-if="extension.icon"
+              :name="extension.icon"
+              class="w-12 h-12"
+            />
+            <UIcon
+              v-else
+              name="i-heroicons-puzzle-piece"
+              class="w-12 h-12 text-gray-400"
+            />
+            <div class="flex-1">
+              <h4 class="font-semibold">
+                {{ extension.name }}
+              </h4>
+              <p class="text-sm text-gray-500 dark:text-gray-400">
+                {{ t('version') }}: {{ extension.version }}
+              </p>
+              <p
+                v-if="extension.author"
+                class="text-sm text-gray-500 dark:text-gray-400"
+              >
+                {{ t('author') }}: {{ extension.author }}
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+    </template>
   </UiDialogConfirm>
 </template>
 
 <script setup lang="ts">
-import type { IHaexHubExtension } from "~/types/haexhub";
+import type { IHaexHubExtension } from '~/types/haexhub'
 
-const emit = defineEmits(["confirm"]);
+const emit = defineEmits(['confirm', 'abort'])
 
-const { t } = useI18n();
+const { t } = useI18n()
 
-defineProps<{ extension?: IHaexHubExtension }>();
+defineProps<{ extension?: IHaexHubExtension }>()
 
-const open = defineModel<boolean>("open");
+const open = defineModel<boolean>('open')
+
+const onAbort = () => {
+  open.value = false
+  emit('abort')
+}
 
 const onConfirm = () => {
-  open.value = false;
+  open.value = false
-  emit("confirm");
+  emit('confirm')
-};
+}
 </script>
 
-<i18n lang="json">{
+<i18n lang="yaml">
-  "de": {
+de:
-    "title": "Erweiterung löschen",
+  title: Erweiterung entfernen
-    "question": "Soll {name} wirklich gelöscht werden?",
+  question: Möchtest du {name} wirklich entfernen?
-    "abort": "Abbrechen",
+  warning:
-    "remove": "Löschen"
+    title: Achtung
-  },
+    description: Diese Aktion kann nicht rückgängig gemacht werden. Alle Daten der Erweiterung werden dauerhaft gelöscht.
-  "en": {
+  version: Version
-    "title": "Remove Extension",
+  author: Autor
-    "question": "Should {name} really be deleted?",
+
-    "abort": "Abort",
+en:
-    "remove": "Remove"
+  title: Remove Extension
-  }
+  question: Do you really want to remove {name}?
-}</i18n>
+  warning:
+    title: Warning
+    description: This action cannot be undone. All extension data will be permanently deleted.
+  version: Version
+  author: Author
+</i18n>

src/components/haex/extension/installed-card.vue

@@ -0,0 +1,157 @@
+<template>
+  <UCard
+    :ui="{
+      root: 'hover:shadow-lg transition-shadow duration-200 cursor-pointer',
+      body: 'flex flex-col gap-3',
+    }"
+    @click="$emit('open')"
+  >
+    <div class="flex items-start gap-4">
+      <!-- Icon -->
+      <div class="flex-shrink-0">
+        <div
+          v-if="extension.icon"
+          class="w-16 h-16 rounded-lg bg-primary/10 flex items-center justify-center"
+        >
+          <UIcon
+            :name="extension.icon"
+            class="w-10 h-10 text-primary"
+          />
+        </div>
+        <div
+          v-else
+          class="w-16 h-16 rounded-lg bg-gray-200 dark:bg-gray-700 flex items-center justify-center"
+        >
+          <UIcon
+            name="i-heroicons-puzzle-piece"
+            class="w-10 h-10 text-gray-400"
+          />
+        </div>
+      </div>
+
+      <!-- Content -->
+      <div class="flex-1 min-w-0">
+        <div class="flex items-start justify-between gap-2">
+          <div class="flex-1 min-w-0">
+            <h3 class="text-lg font-semibold truncate">
+              {{ extension.name }}
+            </h3>
+            <p
+              v-if="extension.author"
+              class="text-sm text-gray-500 dark:text-gray-400"
+            >
+              {{ t('by') }} {{ extension.author }}
+            </p>
+          </div>
+          <UBadge
+            :label="extension.version"
+            color="neutral"
+            variant="subtle"
+          />
+        </div>
+
+        <p
+          v-if="extension.description"
+          class="text-sm text-gray-600 dark:text-gray-300 mt-2 line-clamp-2"
+        >
+          {{ extension.description }}
+        </p>
+
+        <!-- Installed Badge -->
+        <div class="flex items-center gap-2 mt-3">
+          <UBadge
+            :label="t('installed')"
+            color="success"
+            variant="subtle"
+          >
+            <template #leading>
+              <UIcon name="i-heroicons-check-circle" />
+            </template>
+          </UBadge>
+          <UBadge
+            v-if="extension.enabled"
+            :label="t('enabled')"
+            color="primary"
+            variant="soft"
+          />
+          <UBadge
+            v-else
+            :label="t('disabled')"
+            color="neutral"
+            variant="soft"
+          />
+        </div>
+      </div>
+    </div>
+
+    <!-- Actions -->
+    <template #footer>
+      <div class="flex items-center justify-between gap-2">
+        <UButton
+          :label="t('open')"
+          color="primary"
+          icon="i-heroicons-arrow-right"
+          size="sm"
+          @click.stop="$emit('open')"
+        />
+        <div class="flex gap-2">
+          <UButton
+            :label="t('settings')"
+            color="neutral"
+            variant="ghost"
+            icon="i-heroicons-cog-6-tooth"
+            size="sm"
+            @click.stop="$emit('settings')"
+          />
+          <UButton
+            :label="t('remove')"
+            color="error"
+            variant="ghost"
+            icon="i-heroicons-trash"
+            size="sm"
+            @click.stop="$emit('remove')"
+          />
+        </div>
+      </div>
+    </template>
+  </UCard>
+</template>
+
+<script setup lang="ts">
+interface InstalledExtension {
+  id: string
+  name: string
+  version: string
+  author?: string
+  description?: string
+  icon?: string
+  enabled?: boolean
+}
+
+defineProps<{
+  extension: InstalledExtension
+}>()
+
+defineEmits(['open', 'settings', 'remove'])
+
+const { t } = useI18n()
+</script>
+
+<i18n lang="yaml">
+de:
+  by: von
+  installed: Installiert
+  enabled: Aktiviert
+  disabled: Deaktiviert
+  open: Öffnen
+  settings: Einstellungen
+  remove: Entfernen
+en:
+  by: by
+  installed: Installed
+  enabled: Enabled
+  disabled: Disabled
+  open: Open
+  settings: Settings
+  remove: Remove
+</i18n>

src/components/haex/extension/launcher.vue

@@ -0,0 +1,280 @@
+<template>
+  <UDrawer
+    v-model:open="open"
+    direction="right"
+    :title="t('launcher.title')"
+    :description="t('launcher.description')"
+    :ui="{
+      content: 'w-dvw max-w-md sm:max-w-fit',
+    }"
+  >
+    <UButton
+      icon="material-symbols:apps"
+      color="neutral"
+      variant="outline"
+      v-bind="$attrs"
+      size="lg"
+    />
+
+    <template #content>
+      <div class="p-4 h-full overflow-y-auto">
+        <div class="flex flex-wrap">
+          <!-- All launcher items (system windows + enabled extensions, alphabetically sorted) -->
+          <UContextMenu
+            v-for="item in launcherItems"
+            :key="item.id"
+            :items="getContextMenuItems(item)"
+          >
+            <UiButton
+              square
+              size="lg"
+              variant="ghost"
+              :ui="{
+                base: 'size-24 flex flex-wrap text-sm items-center justify-center overflow-visible cursor-grab active:cursor-grabbing',
+                leadingIcon: 'size-10',
+                label: 'w-full',
+              }"
+              :icon="item.icon"
+              :label="item.name"
+              :tooltip="item.name"
+              draggable="true"
+              @click="openItem(item)"
+              @dragstart="handleDragStart($event, item)"
+              @dragend="handleDragEnd"
+            />
+          </UContextMenu>
+
+          <!-- Disabled Extensions (grayed out) -->
+          <UiButton
+            v-for="extension in disabledExtensions"
+            :key="extension.id"
+            square
+            size="xl"
+            variant="ghost"
+            :disabled="true"
+            :ui="{
+              base: 'size-24 flex flex-wrap text-sm items-center justify-center overflow-visible opacity-40',
+              leadingIcon: 'size-10',
+              label: 'w-full',
+            }"
+            :icon="extension.icon || 'i-heroicons-puzzle-piece-solid'"
+            :label="extension.name"
+            :tooltip="`${extension.name} (${t('disabled')})`"
+          />
+        </div>
+      </div>
+    </template>
+  </UDrawer>
+
+  <!-- Uninstall Confirmation Dialog -->
+  <UiDialogConfirm
+    v-model:open="showUninstallDialog"
+    :title="t('uninstall.confirm.title')"
+    :description="
+      t('uninstall.confirm.description', {
+        name: extensionToUninstall?.name || '',
+      })
+    "
+    :confirm-label="t('uninstall.confirm.button')"
+    confirm-icon="i-heroicons-trash"
+    @confirm="confirmUninstall"
+  />
+</template>
+
+<script setup lang="ts">
+defineOptions({
+  inheritAttrs: false,
+})
+
+const extensionStore = useExtensionsStore()
+const windowManagerStore = useWindowManagerStore()
+
+const { t } = useI18n()
+
+const open = ref(false)
+
+// Uninstall dialog state
+const showUninstallDialog = ref(false)
+const extensionToUninstall = ref<LauncherItem | null>(null)
+
+// Unified launcher item type
+interface LauncherItem {
+  id: string
+  name: string
+  icon: string
+  type: 'system' | 'extension'
+}
+
+// Combine system windows and enabled extensions, sorted alphabetically
+const launcherItems = computed(() => {
+  const items: LauncherItem[] = []
+
+  // Add system windows
+  const systemWindows = windowManagerStore.getAllSystemWindows()
+  systemWindows.forEach((sysWin: SystemWindowDefinition) => {
+    items.push({
+      id: sysWin.id,
+      name: sysWin.name,
+      icon: sysWin.icon,
+      type: 'system',
+    })
+  })
+
+  // Add enabled extensions
+  const enabledExtensions = extensionStore.availableExtensions.filter(
+    (ext) => ext.enabled,
+  )
+  enabledExtensions.forEach((ext) => {
+    items.push({
+      id: ext.id,
+      name: ext.name,
+      icon: ext.icon || 'i-heroicons-puzzle-piece-solid',
+      type: 'extension',
+    })
+  })
+
+  // Sort alphabetically by name
+  return items.sort((a, b) => a.name.localeCompare(b.name))
+})
+
+// Disabled extensions (shown grayed out at the end)
+const disabledExtensions = computed(() => {
+  return extensionStore.availableExtensions.filter((ext) => !ext.enabled)
+})
+
+// Open launcher item (system window or extension)
+const openItem = async (item: LauncherItem) => {
+  try {
+    // Open the window with correct type and sourceId
+    await windowManagerStore.openWindowAsync({
+      sourceId: item.id,
+      type: item.type,
+      icon: item.icon,
+      title: item.name,
+    })
+
+    open.value = false
+  } catch (error) {
+    console.log(error)
+  }
+}
+
+// Uninstall extension - shows confirmation dialog first
+const uninstallExtension = async (item: LauncherItem) => {
+  extensionToUninstall.value = item
+  showUninstallDialog.value = true
+}
+
+// Confirm uninstall - actually removes the extension
+const confirmUninstall = async () => {
+  if (!extensionToUninstall.value) return
+
+  try {
+    const extension = extensionStore.availableExtensions.find(
+      (ext) => ext.id === extensionToUninstall.value!.id,
+    )
+    if (!extension) return
+
+    // Close all windows of this extension first
+    const extensionWindows = windowManagerStore.windows.filter(
+      (win) => win.type === 'extension' && win.sourceId === extension.id,
+    )
+
+    for (const win of extensionWindows) {
+      windowManagerStore.closeWindow(win.id)
+    }
+
+    // Uninstall the extension
+    await extensionStore.removeExtensionAsync(
+      extension.publicKey,
+      extension.name,
+      extension.version,
+    )
+
+    // Refresh available extensions list
+    await extensionStore.loadExtensionsAsync()
+
+    // Close dialog and reset state
+    showUninstallDialog.value = false
+    extensionToUninstall.value = null
+  } catch (error) {
+    console.error('Failed to uninstall extension:', error)
+  }
+}
+
+// Get context menu items for launcher item
+const getContextMenuItems = (item: LauncherItem) => {
+  const items = [
+    {
+      label: t('contextMenu.open'),
+      icon: 'i-heroicons-arrow-top-right-on-square',
+      onSelect: () => openItem(item),
+    },
+  ]
+
+  // Add uninstall option for extensions
+  if (item.type === 'extension') {
+    items.push({
+      label: t('contextMenu.uninstall'),
+      icon: 'i-heroicons-trash',
+      onSelect: () => uninstallExtension(item),
+    })
+  }
+
+  return items
+}
+
+// Drag & Drop handling
+const handleDragStart = (event: DragEvent, item: LauncherItem) => {
+  if (!event.dataTransfer) return
+
+  // Store the launcher item data
+  event.dataTransfer.effectAllowed = 'copy'
+  event.dataTransfer.setData(
+    'application/haex-launcher-item',
+    JSON.stringify(item),
+  )
+
+  // Set drag image (optional - uses default if not set)
+  const dragImage = event.target as HTMLElement
+  if (dragImage) {
+    event.dataTransfer.setDragImage(dragImage, 20, 20)
+  }
+}
+
+const handleDragEnd = () => {
+  // Cleanup if needed
+}
+</script>
+
+<i18n lang="yaml">
+de:
+  disabled: Deaktiviert
+  marketplace: Marketplace
+  launcher:
+    title: App Launcher
+    description: Wähle eine App zum Öffnen
+  contextMenu:
+    open: Öffnen
+    uninstall: Deinstallieren
+  uninstall:
+    confirm:
+      title: Erweiterung deinstallieren
+      description: Möchtest du wirklich "{name}" deinstallieren? Diese Aktion kann nicht rückgängig gemacht werden.
+      button: Deinstallieren
+
+en:
+  disabled: Disabled
+  marketplace: Marketplace
+  launcher:
+    title: App Launcher
+    description: Select an app to open
+  contextMenu:
+    open: Open
+    uninstall: Uninstall
+  uninstall:
+    confirm:
+      title: Uninstall Extension
+      description: Do you really want to uninstall "{name}"? This action cannot be undone.
+      button: Uninstall
+</i18n>

src/components/haex/extension/manifest/permissions/database.vue

@@ -15,7 +15,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(read).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(read).at(0)"
@@ -42,7 +42,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(write).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(write).at(0)"
@@ -69,7 +69,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(create).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(create).at(0)"

src/components/haex/extension/manifest/permissions/filesystem.vue

@@ -14,7 +14,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(read).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(read).at(0)"
@@ -41,7 +41,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(write).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(write).at(0)"

src/components/haex/extension/manifest/permissions/http.vue

@@ -15,7 +15,7 @@
             type="checkbox"
             class="checkbox"
             :checked="Object.values(access).at(0)"
-          />
+          >
           <label
             class="label-text text-base"
             :for="Object.keys(access).at(0)"

src/components/haex/extension/marketplace-card.vue

@@ -0,0 +1,190 @@
+<template>
+  <UCard
+    :ui="{
+      root: 'hover:shadow-lg transition-shadow duration-200 cursor-pointer',
+      body: 'flex flex-col gap-3',
+    }"
+    @click="$emit('click')"
+  >
+    <div class="flex items-start gap-4">
+      <!-- Icon -->
+      <div class="shrink-0">
+        <div
+          v-if="extension.icon"
+          class="w-16 h-16 rounded-lg bg-primary/10 flex items-center justify-center"
+        >
+          <UIcon
+            :name="extension.icon"
+            class="w-10 h-10 text-primary"
+          />
+        </div>
+        <div
+          v-else
+          class="w-16 h-16 rounded-lg bg-gray-200 dark:bg-gray-700 flex items-center justify-center"
+        >
+          <UIcon
+            name="i-heroicons-puzzle-piece"
+            class="w-10 h-10 text-gray-400"
+          />
+        </div>
+      </div>
+
+      <!-- Content -->
+      <div class="flex-1 min-w-0">
+        <div class="flex items-start justify-between gap-2">
+          <div class="flex-1 min-w-0">
+            <h3 class="text-lg font-semibold truncate">
+              {{ extension.name }}
+            </h3>
+            <p
+              v-if="extension.author"
+              class="text-sm text-gray-500 dark:text-gray-400"
+            >
+              {{ t('by') }} {{ extension.author }}
+            </p>
+          </div>
+          <UBadge
+            :label="extension.version"
+            color="neutral"
+            variant="subtle"
+          />
+        </div>
+
+        <p
+          v-if="extension.description"
+          class="hidden @lg:flex text-sm text-gray-600 dark:text-gray-300 mt-2 line-clamp-2"
+        >
+          {{ extension.description }}
+        </p>
+
+        <!-- Stats and Status -->
+        <div
+          class="flex items-center gap-4 mt-3 text-sm text-gray-500 dark:text-gray-400"
+        >
+          <div
+            v-if="extension.isInstalled"
+            class="flex items-center gap-1 text-success font-medium"
+          >
+            <UIcon name="i-heroicons-check-circle-solid" />
+            <span v-if="!extension.installedVersion">{{ t('installed') }}</span>
+            <span v-else>{{
+              t('installedVersion', { version: extension.installedVersion })
+            }}</span>
+          </div>
+          <div
+            v-if="extension.downloads"
+            class="flex items-center gap-1"
+          >
+            <UIcon name="i-heroicons-arrow-down-tray" />
+            <span>{{ formatNumber(extension.downloads) }}</span>
+          </div>
+          <div
+            v-if="extension.rating"
+            class="flex items-center gap-1"
+          >
+            <UIcon name="i-heroicons-star-solid" />
+            <span>{{ extension.rating }}</span>
+          </div>
+          <div
+            v-if="extension.verified"
+            class="flex items-center gap-1 text-green-600 dark:text-green-400"
+          >
+            <UIcon name="i-heroicons-check-badge-solid" />
+            <span>{{ t('verified') }}</span>
+          </div>
+        </div>
+
+        <!-- Tags -->
+        <div
+          v-if="extension.tags?.length"
+          class="flex flex-wrap gap-1 mt-2"
+        >
+          <UBadge
+            v-for="tag in extension.tags.slice(0, 3)"
+            :key="tag"
+            :label="tag"
+            size="xs"
+            color="primary"
+            variant="soft"
+          />
+        </div>
+      </div>
+    </div>
+
+    <!-- Actions -->
+    <template #footer>
+      <div class="flex items-center justify-between gap-2">
+        <UButton
+          :label="getInstallButtonLabel()"
+          :color="
+            extension.isInstalled && !extension.installedVersion
+              ? 'neutral'
+              : 'primary'
+          "
+          :disabled="extension.isInstalled && !extension.installedVersion"
+          :icon="
+            extension.isInstalled && !extension.installedVersion
+              ? 'i-heroicons-check'
+              : 'i-heroicons-arrow-down-tray'
+          "
+          size="sm"
+          @click.stop="$emit('install')"
+        />
+        <UButton
+          :label="t('details')"
+          color="neutral"
+          variant="ghost"
+          size="sm"
+          @click.stop="$emit('details')"
+        />
+      </div>
+    </template>
+  </UCard>
+</template>
+
+<script setup lang="ts">
+import type { IMarketplaceExtension } from '~/types/haexhub'
+
+const props = defineProps<{
+  extension: IMarketplaceExtension
+}>()
+
+defineEmits(['click', 'install', 'details'])
+
+const { t } = useI18n()
+
+const formatNumber = (num: number) => {
+  if (num >= 1000000) return `${(num / 1000000).toFixed(1)}M`
+  if (num >= 1000) return `${(num / 1000).toFixed(1)}K`
+  return num.toString()
+}
+
+const getInstallButtonLabel = () => {
+  if (!props.extension.isInstalled) {
+    return t('install')
+  }
+  if (props.extension.installedVersion) {
+    return t('update')
+  }
+  return t('installed')
+}
+</script>
+
+<i18n lang="yaml">
+de:
+  by: von
+  install: Installieren
+  installed: Installiert
+  installedVersion: 'Installiert (v{version})'
+  update: Aktualisieren
+  details: Details
+  verified: Verifiziert
+en:
+  by: by
+  install: Install
+  installed: Installed
+  installedVersion: 'Installed (v{version})'
+  update: Update
+  details: Details
+  verified: Verified
+</i18n>

src/components/haex/extension/permission/item.vue

@@ -0,0 +1,128 @@
+<template>
+  <div
+    v-if="menuEntry"
+    class="flex items-center justify-between gap-4 p-3 rounded-lg border border-base-300 bg-base-100"
+  >
+    <div class="flex-1 min-w-0">
+      <div class="font-medium truncate">
+        {{ modelValue.target }}
+      </div>
+      <div
+        v-if="modelValue.operation"
+        class="text-sm text-gray-500 dark:text-gray-400"
+      >
+        {{ t(`operation.${modelValue.operation}`) }}
+      </div>
+    </div>
+
+    <div class="flex items-center gap-2">
+      <!-- Status Selector -->
+      <USelectMenu
+        v-model="menuEntry"
+        :items="statusOptions"
+        class="w-44"
+        :search-input="false"
+      >
+        <template #leading>
+          <UIcon
+            :name="getStatusIcon(menuEntry?.value)"
+            :class="getStatusColor(menuEntry?.value)"
+          />
+        </template>
+
+        <template #item-leading="{ item }">
+          <UIcon
+            :name="getStatusIcon(item?.value)"
+            :class="getStatusColor(item?.value)"
+          />
+        </template>
+      </USelectMenu>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { PermissionEntry } from '~~/src-tauri/bindings/PermissionEntry'
+import type { PermissionStatus } from '~~/src-tauri/bindings/PermissionStatus'
+
+const permissionEntry = defineModel<PermissionEntry>({ required: true })
+
+const menuEntry = computed({
+  get: () =>
+    statusOptions.value.find(
+      (option) => option.value == permissionEntry.value.status,
+    ),
+  set(newStatus) {
+    const status =
+      statusOptions.value.find((option) => option.value == newStatus?.value)
+        ?.value || 'denied'
+    if (isPermissionStatus(status)) {
+      permissionEntry.value.status = status
+    } else {
+      permissionEntry.value.status = 'denied'
+    }
+  },
+})
+
+const { t } = useI18n()
+
+const isPermissionStatus = (value: string): value is PermissionStatus => {
+  return ['ask', 'granted', 'denied'].includes(value)
+}
+
+const statusOptions = computed(() => [
+  {
+    value: 'granted',
+    label: t('status.granted'),
+    icon: 'i-heroicons-check-circle',
+    color: 'text-green-500',
+  },
+  {
+    value: 'ask',
+    label: t('status.ask'),
+    icon: 'i-heroicons-question-mark-circle',
+    color: 'text-yellow-500',
+  },
+  {
+    value: 'denied',
+    label: t('status.denied'),
+    icon: 'i-heroicons-x-circle',
+    color: 'text-red-500',
+  },
+])
+
+const getStatusIcon = (status: string) => {
+  const option = statusOptions.value.find((o) => o.value === status)
+  return option?.icon || 'i-heroicons-question-mark-circle'
+}
+
+const getStatusColor = (status: string) => {
+  const option = statusOptions.value.find((o) => o.value === status)
+  return option?.color || 'text-gray-500'
+}
+</script>
+
+<i18n lang="yaml">
+de:
+  status:
+    granted: Erlaubt
+    ask: Nachfragen
+    denied: Verweigert
+  operation:
+    read: Lesen
+    write: Schreiben
+    readWrite: Lesen & Schreiben
+    request: Anfrage
+    execute: Ausführen
+en:
+  status:
+    granted: Granted
+    ask: Ask
+    denied: Denied
+  operation:
+    read: Read
+    write: Write
+    readWrite: Read & Write
+    request: Request
+    execute: Execute
+</i18n>

src/components/haex/extension/permission/list.vue

@@ -0,0 +1,30 @@
+<template>
+  <div
+    v-if="modelValue?.length"
+    class="flex flex-col gap-2"
+  >
+    <h5
+      v-if="title"
+      class="text-sm font-semibold text-gray-700 dark:text-gray-300"
+    >
+      {{ title }}
+    </h5>
+    <div class="flex flex-col gap-2">
+      <HaexExtensionPermissionItem
+        v-for="(perm, index) in modelValue"
+        :key="perm.target"
+        v-model="modelValue[index]!"
+      />
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { PermissionEntry } from '~~/src-tauri/bindings/PermissionEntry'
+
+defineProps<{
+  title?: string
+}>()
+
+const modelValue = defineModel<PermissionEntry[]>({ default: () => [] })
+</script>

src/components/haex/menu/applications.vue

@@ -1,58 +0,0 @@
-<template>
-  <UPopover v-model:open="open">
-    <UButton
-      icon="material-symbols:apps"
-      color="neutral"
-      variant="outline"
-      v-bind="$attrs"
-      size="xl"
-    />
-
-    <template #content>
-      <ul
-        class="p-4 max-h-96 grid grid-cols-3 gap-2 overflow-scroll"
-        @click="open = false"
-      >
-        <UiButton
-          v-for="item in menu"
-          :key="item.id"
-          square
-          size="xl"
-          variant="ghost"
-          :ui="{
-            base: 'size-24 flex flex-wrap  text-sm items-center justify-center overflow-visible',
-            leadingIcon: 'size-10',
-            label: 'w-full',
-          }"
-          :icon="item.icon"
-          :label="item.name"
-          :tooltip="item.name"
-          @click="item.onSelect"
-        />
-        <!-- <UiButton
-          v-for="item in extensionLinks"
-          :key="item.id"
-          v-bind="item"
-          icon-type="svg"
-        /> -->
-      </ul>
-    </template>
-  </UPopover>
-</template>
-
-<script setup lang="ts">
-//const { extensionLinks } = storeToRefs(useExtensionsStore())
-const { menu } = storeToRefs(useSidebarStore())
-
-const open = ref(false)
-</script>
-
-<i18n lang="yaml">
-de:
-  settings: 'Einstellungen'
-  close: 'Vault schließen'
-
-en:
-  settings: 'Settings'
-  close: 'Close Vault'
-</i18n>

src/components/haex/pass/card/group.vue

@@ -1,107 +0,0 @@
-<template>
-  <HaexPassCard
-    :title
-    @close="onClose"
-  >
-    <div class="flex flex-col gap-4 w-full p-4">
-      <slot />
-
-      <UiInput
-        v-show="!read_only"
-        v-model.trim="passwordGroup.name"
-        :label="t('group.name')"
-        :placeholder="t('group.name')"
-        :with-copy-button="read_only"
-        :read_only
-        autofocus
-      />
-
-      <UiInput
-        v-show="!read_only || passwordGroup.description?.length"
-        v-model.trim="passwordGroup.description"
-        :read_only
-        :label="t('group.description')"
-        :placeholder="t('group.description')"
-        :with-copy-button="read_only"
-      />
-
-      <UiSelectColor
-        v-model="passwordGroup.color"
-        :read_only
-        :label="t('group.color')"
-        :placeholder="t('group.color')"
-      />
-
-      <UiSelectIcon
-        v-model="passwordGroup.icon"
-        :read_only
-        :label="t('group.icon')"
-        :placeholder="t('group.icon')"
-      />
-    </div>
-
-    <slot name="footer" />
-  </HaexPassCard>
-</template>
-
-<script setup lang="ts">
-import type { RouteLocationNormalizedLoadedGeneric } from 'vue-router'
-import type { SelectHaexPasswordsGroups } from '~~/src-tauri/database/schemas/vault'
-
-const { t } = useI18n()
-const showConfirmation = ref(false)
-const passwordGroup = defineModel<SelectHaexPasswordsGroups>({ required: true })
-const read_only = defineModel<boolean>('read_only')
-const props = defineProps<{
-  originally: SelectHaexPasswordsGroups
-  title: string
-}>()
-
-defineEmits<{
-  submit: [to?: RouteLocationNormalizedLoadedGeneric]
-  close: [void]
-  back: [void]
-  reject: [to?: RouteLocationNormalizedLoadedGeneric]
-}>()
-
-const hasChanges = computed(() => {
-  console.log('group has changes', props.originally, passwordGroup.value)
-  if (!props.originally) {
-    if (
-      passwordGroup.value.color?.length ||
-      passwordGroup.value.description?.length ||
-      passwordGroup.value.icon?.length ||
-      passwordGroup.value.name?.length
-    ) {
-      return true
-    } else {
-      return false
-    }
-  }
-  return (
-    JSON.stringify(props.originally) !== JSON.stringify(passwordGroup.value)
-  )
-})
-
-const onClose = () => {
-  /* if (props.originally) passwordGroup.value = { ...props.originally };
-  emit('close'); */
-  console.log('close group card')
-}
-</script>
-
-<i18n lang="yaml">
-de:
-  group:
-    name: Name
-    description: Beschreibung
-    icon: Icon
-    color: Farbe
-
-en:
-  group:
-    name: Name
-    description: Description
-    icon: Icon
-    color: Color
-</i18n>

src/components/haex/pass/card/index.vue

@@ -1,12 +0,0 @@
-<template>
-  <UiCard
-    :title
-    :icon
-  >
-    <slot />
-  </UiCard>
-</template>
-
-<script setup lang="ts">
-defineProps<{ title: string; icon?: string }>()
-</script>

src/components/haex/pass/dialog/deleteItem.vue

@@ -1,46 +0,0 @@
-<template>
-  <UiDialogConfirm
-    v-model:open="showConfirmDeleteDialog"
-    :confirm-label="final ? t('final.label') : t('label')"
-    :title="final ? t('final.title') : t('title', { itemName })"
-    @abort="$emit('abort')"
-    @confirm="$emit('confirm')"
-  >
-    <template #body>
-      {{
-        final ? t('final.question', { itemName }) : t('question', { itemName })
-      }}
-    </template>
-  </UiDialogConfirm>
-</template>
-
-<script setup lang="ts">
-const { t } = useI18n()
-
-const showConfirmDeleteDialog = defineModel<boolean>('open')
-defineProps<{ final?: boolean; itemName?: string | null }>()
-
-defineEmits(['confirm', 'abort'])
-</script>
-
-<i18n lang="yaml">
-de:
-  title: Eintrag löschen
-  question: Soll der Eintrag "{itemName}" in den Papierkorb verschoben werden?
-  label: Verschieben
-
-  final:
-    title: Eintrag endgültig löschen
-    question: Soll der Eintrag "{itemName}" endgültig gelöscht werden?
-    label: Löschen
-
-en:
-  title: Delete Entry
-  question: Should the “{itemName}” entry be moved to the recycle bin?
-  label: Move
-
-  final:
-    title: Delete entry permanently
-    question: Should the entry “{itemName}” be permanently deleted?
-    label: Delete
-</i18n>

src/components/haex/pass/dialog/unsavedChanges.vue

@@ -1,51 +0,0 @@
-<template>
-  <UiDialogConfirm
-    v-model:open="showUnsavedChangesDialog"
-    :confirm-label="t('label')"
-    :title="t('title')"
-    @abort="$emit('abort')"
-    @confirm="onConfirm"
-  >
-    <template #body>
-      <div class="flex items-center h-full">
-        {{ t('question') }}
-      </div>
-    </template>
-  </UiDialogConfirm>
-</template>
-
-<script setup lang="ts">
-const { t } = useI18n()
-
-const showUnsavedChangesDialog = defineModel<boolean>('open')
-const ignoreChanges = defineModel<boolean>('ignoreChanges')
-const { hasChanges } = defineProps<{ hasChanges: boolean }>()
-
-const emit = defineEmits(['confirm', 'abort'])
-
-const onConfirm = () => {
-  ignoreChanges.value = true
-  emit('confirm')
-}
-
-onBeforeRouteLeave(() => {
-  if (hasChanges && !ignoreChanges.value) {
-    showUnsavedChangesDialog.value = true
-    return false
-  }
-
-  return true
-})
-</script>
-
-<i18n lang="yaml">
-de:
-  title: Nicht gespeicherte Änderungen
-  question: Sollen die Änderungen verworfen werden?
-  label: Verwerfen
-
-en:
-  title: Unsaved changes
-  question: Should the changes be discarded?
-  label: Discard
-</i18n>

src/components/haex/pass/group/breadcrumbs.vue

@@ -1,59 +0,0 @@
-<template>
-  <ul class="flex items-center gap-2 p-2">
-    <li>
-      <NuxtLinkLocale :to="{ name: 'passwordGroupItems' }">
-        <Icon
-          name="mdi:safe"
-          size="24"
-        />
-      </NuxtLinkLocale>
-    </li>
-
-    <li
-      v-for="item in items"
-      :key="item.id"
-      class="flex items-center gap-2"
-    >
-      <Icon
-        name="tabler:chevron-right"
-        class="rtl:rotate-180"
-      />
-      <NuxtLinkLocale
-        :to="{ name: 'passwordGroupItems', params: { groupId: item.id } }"
-      >
-        {{ item.name }}
-      </NuxtLinkLocale>
-    </li>
-
-    <li class="ml-2">
-      <UTooltip :text="t('edit')">
-        <NuxtLinkLocale
-          :to="{
-            name: 'passwordGroupEdit',
-            params: { groupId: lastGroup?.id },
-          }"
-        >
-          <Icon name="mdi:pencil" />
-        </NuxtLinkLocale>
-      </UTooltip>
-    </li>
-  </ul>
-</template>
-
-<script setup lang="ts">
-import type { SelectHaexPasswordsGroups } from '~~/src-tauri/database/schemas/vault'
-
-const groups = defineProps<{ items: SelectHaexPasswordsGroups[] }>()
-
-const lastGroup = computed(() => groups.items.at(-1))
-
-const { t } = useI18n()
-</script>
-
-<i18n lang="yaml">
-de:
-  edit: Bearbeiten
-
-en:
-  edit: Edit
-</i18n>

src/components/haex/pass/group/composables.ts

@@ -1,71 +0,0 @@
-export const usePasswordGroup = () => {
-  const areItemsEqual = (
-    groupA: unknown | unknown[] | null,
-    groupB: unknown | unknown[] | null,
-  ) => {
-    console.log('compare values', groupA, groupB)
-    if (groupA === groupB) return true
-
-    if (Array.isArray(groupA) && Array.isArray(groupB)) {
-      console.log('compare object arrays', groupA, groupB)
-      if (groupA.length === groupB.length) return true
-
-      return groupA.some((group, index) => {
-        return areObjectsEqual(group, groupA[index])
-      })
-    }
-    return areObjectsEqual(groupA, groupB)
-  }
-
-  const deepEqual = (obj1: unknown, obj2: unknown) => {
-    console.log('compare values', obj1, obj2)
-    if (obj1 === obj2) return true
-
-    // Null/undefined Check
-    if (obj1 == null || obj2 == null) return obj1 === obj2
-
-    // Typ-Check
-    if (typeof obj1 !== typeof obj2) return false
-
-    // Primitive Typen
-    if (typeof obj1 !== 'object') return obj1 === obj2
-
-    // Arrays
-    if (Array.isArray(obj1) !== Array.isArray(obj2)) return false
-
-    if (Array.isArray(obj1)) {
-      if (obj1.length !== obj2.length) return false
-      for (let i = 0; i < obj1.length; i++) {
-        if (!deepEqual(obj1[i], obj2[i])) return false
-      }
-      return true
-    }
-
-    // Date Objekte
-    if (obj1 instanceof Date && obj2 instanceof Date) {
-      return obj1.getTime() === obj2.getTime()
-    }
-
-    // RegExp Objekte
-    if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
-      return obj1.toString() === obj2.toString()
-    }
-
-    // Objekte
-    const keys1 = Object.keys(obj1)
-    const keys2 = Object.keys(obj2)
-
-    if (keys1.length !== keys2.length) return false
-
-    for (const key of keys1) {
-      if (!keys2.includes(key)) return false
-      if (!deepEqual(obj1[key], obj2[key])) return false
-    }
-
-    return true
-  }
-  return {
-    areItemsEqual,
-    deepEqual,
-  }
-}

src/components/haex/pass/group/index.vue

@@ -1,106 +0,0 @@
-<template>
-  <UCard
-    v-if="group"
-    :ui="{ root: [''] }"
-  >
-    <template #header>
-      <div class="flex items-center gap-2">
-        <Icon
-          :name="
-            mode === 'edit'
-              ? 'mdi:folder-edit-outline'
-              : 'mdi:folder-plus-outline'
-          "
-          size="24"
-        />
-        <span>{{ mode === 'edit' ? t('title.edit') : t('title.create') }}</span>
-      </div>
-    </template>
-
-    <form class="flex flex-col gap-4 w-full p-4">
-      <UiInput
-        ref="nameRef"
-        v-model="group.name"
-        :label="t('name')"
-        :placeholder="t('name')"
-        :read-only
-        autofocus
-        @keyup.enter="$emit('submit')"
-      />
-
-      <UiInput
-        v-model="group.description"
-        :label="t('description')"
-        :placeholder="t('description')"
-        :read-only
-        @keyup.enter="$emit('submit')"
-      />
-
-      <div class="flex flex-wrap gap-4">
-        <!-- <UiSelectIcon
-            v-model="group.icon"
-            default-icon="mdi:folder-outline"
-            :readOnly
-          />
-
-          <UiSelectColor
-            v-model="group.color"
-            :readOnly
-          /> -->
-      </div>
-    </form>
-  </UCard>
-</template>
-
-<script setup lang="ts">
-import type { SelectHaexPasswordsGroups } from '~~/src-tauri/database/schemas/vault'
-
-const group = defineModel<SelectHaexPasswordsGroups | null>()
-const { readOnly = false } = defineProps<{
-  readOnly?: boolean
-  mode: 'create' | 'edit'
-}>()
-const emit = defineEmits(['close', 'submit'])
-
-const { t } = useI18n()
-
-const nameRef = useTemplateRef('nameRef')
-onStartTyping(() => {
-  nameRef.value?.$el.focus()
-})
-
-const { escape } = useMagicKeys()
-
-watchEffect(async () => {
-  if (escape?.value) {
-    await nextTick()
-    emit('close')
-  }
-})
-</script>
-
-<i18n lang="yaml">
-de:
-  name: Name
-  description: Beschreibung
-  icon: Icon
-  color: Farbe
-  create: Erstellen
-  save: Speichern
-  abort: Abbrechen
-  title:
-    create: Gruppe erstellen
-    edit: Gruppe ändern
-
-en:
-  name: Name
-  description: Description
-  icon: Icon
-  color: Color
-  create: Create
-  save: Save
-  abort: Abort
-  title:
-    create: Create group
-    edit: Edit group
-</i18n>

src/components/haex/pass/item/details.vue

@@ -1,127 +0,0 @@
-<template>
-  <div class="h-full overflow-scroll">
-    <form
-      class="flex flex-col gap-4 w-full p-4"
-      @submit.prevent="$emit('submit')"
-    >
-      <UiInput
-        v-show="!readOnly || itemDetails.title"
-        ref="titleRef"
-        v-model.trim="itemDetails.title"
-        :check-input="check"
-        :label="t('item.title')"
-        :placeholder="t('item.title')"
-        :read-only
-        :with-copy-button
-        autofocus
-        @keyup.enter="$emit('submit')"
-      />
-
-      <UiInput
-        v-show="!readOnly || itemDetails.username"
-        v-model.trim="itemDetails.username"
-        :check-input="check"
-        :label="t('item.username')"
-        :placeholder="t('item.username')"
-        :with-copy-button
-        :read-only
-        @keyup.enter="$emit('submit')"
-      />
-
-      <UiInputPassword
-        v-show="!readOnly || itemDetails.password"
-        v-model.trim="itemDetails.password"
-        :check-input="check"
-        :read-only
-        :with-copy-button
-        @keyup.enter="$emit('submit')"
-      >
-        <template #append>
-          <!-- <UiDialogPasswordGenerator
-            v-if="!readOnly"
-            class="join-item"
-            :password="itemDetails.password"
-            v-model="preventClose"
-          /> -->
-        </template>
-      </UiInputPassword>
-
-      <UiInputUrl
-        v-show="!readOnly || itemDetails.url"
-        v-model="itemDetails.url"
-        :label="t('item.url')"
-        :placeholder="t('item.url')"
-        :read-only
-        :with-copy-button
-        @keyup.enter="$emit('submit')"
-      />
-
-      <!-- <UiSelectIcon
-        v-show="!readOnly"
-        :default-icon="defaultIcon || 'mdi:key-outline'"
-        :readOnly
-        v-model="itemDetails.icon"
-      /> -->
-
-      <UiTextarea
-        v-show="!readOnly || itemDetails.note"
-        v-model="itemDetails.note"
-        :label="t('item.note')"
-        :placeholder="t('item.note')"
-        :readOnly
-        :with-copy-button
-        @keyup.enter.stop
-        color="error"
-      />
-    </form>
-  </div>
-</template>
-
-<script setup lang="ts">
-import type { SelectHaexPasswordsItemDetails } from '~~/src-tauri/database/schemas/vault'
-
-defineProps<{
-  defaultIcon?: string | null
-  readOnly?: boolean
-  withCopyButton?: boolean
-}>()
-
-defineEmits(['submit'])
-const { t } = useI18n()
-
-const itemDetails = defineModel<SelectHaexPasswordsItemDetails>({
-  required: true,
-})
-
-//const preventClose = defineModel<boolean>('preventClose')
-
-const check = defineModel<boolean>('check-input', { default: false })
-
-/* onKeyStroke('escape', (e) => {
-  e.stopPropagation()
-  e.stopImmediatePropagation()
-}) */
-
-const titleRef = useTemplateRef('titleRef')
-onStartTyping(() => {
-  titleRef.value?.$el?.focus()
-})
-</script>
-
-<i18n lang="yaml">
-de:
-  item:
-    title: Titel
-    username: Nutzername
-    password: Passwort
-    url: Url
-    note: Notiz
-
-en:
-  item:
-    title: Title
-    username: Username
-    password: Password
-    url: Url
-    note: Note
-</i18n>