Merge branch 'main' of http://synbox.ruv.wtf:8418/litruv/cinny-desktop

- Introduced PLUGIN_BUTTON_API.md detailing button registration, UI locations, and usage examples.
- Added PLUGIN_SYSTEM_IMPLEMENTATION.md summarizing implemented features, usage examples, and API details for the plugin system.

.gitea/workflows/build.yml

@@ -8,321 +8,354 @@ on:
     tags:
       - 'v*'
 
-env:
-  TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-
 jobs:
-  check-version:
+  increment-version:
     runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/main' && !startsWith(github.ref, 'refs/tags/')
+    if: github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, '[skip ci]')
     outputs:
-      should_release: ${{ steps.check.outputs.should_release }}
-      version: ${{ steps.check.outputs.version }}
+      version: ${{ steps.bump.outputs.VERSION }}
+      should_build: ${{ steps.bump.outputs.SHOULD_BUILD }}
     
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
       
-      - name: Check if version tag exists
-        id: check
+      - name: Bump patch version
+        id: bump
         run: |
-          VERSION=$(grep -Po '"version":\s*"\K[^"]+' src-tauri/tauri.conf.json | head -1)
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          if git rev-parse "v$VERSION" >/dev/null 2>&1; then
-            echo "Tag v$VERSION already exists"
-            echo "should_release=false" >> $GITHUB_OUTPUT
-          else
-            echo "Tag v$VERSION does not exist, will create release"
-            echo "should_release=true" >> $GITHUB_OUTPUT
-          fi
-  
-  create-tag:
-    runs-on: ubuntu-latest
-    needs: check-version
-    if: needs.check-version.outputs.should_release == 'true'
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+          # Get current version from package.json
+          CURRENT=$(grep -Po '"version":\s*"\K[^"]+' package.json | head -1)
+          echo "Current version: $CURRENT"
+          
+          # Split and increment patch
+          MAJOR=$(echo $CURRENT | cut -d. -f1)
+          MINOR=$(echo $CURRENT | cut -d. -f2)
+          PATCH=$(echo $CURRENT | cut -d. -f3)
+          NEW_PATCH=$((PATCH + 1))
+          NEW_VERSION="${MAJOR}.${MINOR}.${NEW_PATCH}"
+          echo "New version: $NEW_VERSION"
+          
+          # Update package.json
+          sed -i "s/\"version\": \"${CURRENT}\"/\"version\": \"${NEW_VERSION}\"/" package.json
+          
+          # Verify the change
+          grep '"version"' package.json | head -1
+          
+          echo "VERSION=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "SHOULD_BUILD=true" >> $GITHUB_OUTPUT
       
-      - name: Create and push tag
+      - name: Commit and push version bump
         run: |
           git config user.name "GitHub Actions"
           git config user.email "actions@github.com"
-          git tag -a "v${{ needs.check-version.outputs.version }}" -m "Release v${{ needs.check-version.outputs.version }}"
-          git push origin "v${{ needs.check-version.outputs.version }}"
+          git add package.json
+          git commit -m "chore: bump version to ${{ steps.bump.outputs.VERSION }} [skip ci]"
+          git push
 
   build-windows:
     runs-on: windows
+    needs: increment-version
+    if: always() && (needs.increment-version.outputs.should_build == 'true' || needs.increment-version.result == 'skipped')
     
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-          submodules: recursive
+          submodules: false
+          ref: ${{ github.ref_name }}
+      
+      - name: Checkout submodules manually
+        shell: powershell
+        run: |
+          git submodule update --init --recursive
+      
+      - name: Pull latest (after version bump)
+        if: github.ref == 'refs/heads/main'
+        shell: powershell
+        run: git pull origin main
       
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: '20'
       
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-      
       - name: Install dependencies (root)
-        run: npm install
+        run: npm ci --prefer-offline
       
       - name: Install dependencies (cinny)
         working-directory: ./cinny
-        run: npm install
+        run: npm ci --prefer-offline
       
-      - name: Build Tauri app
-        run: npm run tauri build
-      
-      - name: Rename MSI
+      - name: Clean previous builds
         shell: powershell
         run: |
-          $msi = Get-ChildItem "src-tauri/target/release/bundle/msi/*.msi" | Select-Object -First 1
-          $newName = "Cinny-Windows-x64.msi"
-          Copy-Item $msi.FullName "src-tauri/target/release/bundle/msi/$newName"
+          if (Test-Path cinny/dist) { Remove-Item -Recurse -Force cinny/dist }
+          if (Test-Path dist-electron) { Remove-Item -Recurse -Force dist-electron }
       
-      - name: Upload MSI installer
+      - name: Build Electron app
+        run: npm run build:local -- --win
+        env:
+          GH_TOKEN: ${{ secrets.GHTOKEN }}
+      
+      - name: Upload NSIS Installer (x64)
         uses: actions/upload-artifact@v3
         with:
-          name: Cinny-Windows-x64.msi
-          path: src-tauri/target/release/bundle/msi/Cinny-Windows-x64.msi
+          name: Paarrot-Setup-x64.exe
+          path: dist-electron/Paarrot-*-win-x64.exe
+      
+      - name: Upload latest.yml
+        uses: actions/upload-artifact@v3
+        with:
+          name: latest.yml
+          path: dist-electron/latest.yml
+      
+      - name: List build output
+        shell: powershell
+        run: |
+          Get-ChildItem -Path dist-electron -Recurse | Select-Object FullName
 
   build-linux:
     runs-on: ubuntu-latest
+    needs: increment-version
+    if: always() && (needs.increment-version.outputs.should_build == 'true' || needs.increment-version.result == 'skipped')
     
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           submodules: recursive
+          ref: ${{ github.ref_name }}
+      
+      - name: Pull latest (after version bump)
+        if: github.ref == 'refs/heads/main'
+        run: git pull origin main
       
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: '20'
       
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-      
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev rpm
-      
       - name: Install dependencies (root)
-        run: npm install
+        run: npm ci --prefer-offline
       
       - name: Install dependencies (cinny)
         working-directory: ./cinny
-        run: npm install
+        run: npm ci --prefer-offline
       
-      - name: Build Tauri app
-        run: npm run tauri build
-      
-      - name: Rename Linux packages
+      - name: Clean previous builds
         run: |
-          cp src-tauri/target/release/bundle/appimage/*.AppImage src-tauri/target/release/bundle/appimage/Cinny-Linux-x64.AppImage
-          cp src-tauri/target/release/bundle/deb/*.deb src-tauri/target/release/bundle/deb/Cinny-Linux-x64.deb
-          cp src-tauri/target/release/bundle/rpm/*.rpm src-tauri/target/release/bundle/rpm/Cinny-Linux-x64.rpm
-          # Copy signature file for updater
-          if [ -f src-tauri/target/release/bundle/appimage/*.AppImage.sig ]; then
-            cp src-tauri/target/release/bundle/appimage/*.AppImage.sig src-tauri/target/release/bundle/appimage/Cinny-Linux-x64.AppImage.sig
-          fi
+          rm -rf cinny/dist dist-electron
+      
+      - name: Build Electron app
+        run: npm run build:local -- --linux
+        env:
+          GH_TOKEN: ${{ secrets.GHTOKEN }}
       
       - name: Upload AppImage
         uses: actions/upload-artifact@v3
         with:
-          name: Cinny-Linux-x64.AppImage
-          path: src-tauri/target/release/bundle/appimage/Cinny-Linux-x64.AppImage
+          name: Paarrot-Linux-x64.AppImage
+          path: dist-electron/Paarrot-*.AppImage
       
-      - name: Upload AppImage Signature
-        uses: actions/upload-artifact@v3
-        if: always()
-        with:
-          name: Cinny-Linux-x64.AppImage.sig
-          path: src-tauri/target/release/bundle/appimage/Cinny-Linux-x64.AppImage.sig
-      
-      - name: Upload DEB package
+      - name: Upload latest-linux.yml
         uses: actions/upload-artifact@v3
         with:
-          name: Cinny-Linux-x64.deb
-          path: src-tauri/target/release/bundle/deb/Cinny-Linux-x64.deb
-      
-      - name: Upload RPM package
-        uses: actions/upload-artifact@v3
-        with:
-          name: Cinny-Linux-x64.rpm
-          path: src-tauri/target/release/bundle/rpm/Cinny-Linux-x64.rpm
-
-  build-android:
-    runs-on: windows
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-      
-      - name: Setup Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-      
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-          target: aarch64-linux-android
-      
-      - name: Add Android targets
-        run: |
-          rustup target add aarch64-linux-android --toolchain stable
-          rustup target add armv7-linux-androideabi --toolchain stable
-          rustup target add x86_64-linux-android --toolchain stable
-          rustup target add i686-linux-android --toolchain stable
-      
-      - name: Install dependencies (root)
-        run: npm install
-      
-      - name: Install dependencies (cinny)
-        working-directory: ./cinny
-        run: npm install
-      
-      - name: Build Android APK
-        shell: powershell
-        run: |
-          $env:PATH = "$env:USERPROFILE\.cargo\bin;$env:PATH"
-          npm run tauri android build
-        env:
-          ANDROID_HOME: ${{ env.ANDROID_HOME }}
-          NDK_HOME: ${{ env.ANDROID_HOME }}/ndk/25.2.9519653
-          RUSTUP_TOOLCHAIN: stable
-      
-      - name: Sign APK
-        shell: powershell
-        run: |
-          $unsignedApk = "src-tauri/gen/android/app/build/outputs/apk/universal/release/app-universal-release-unsigned.apk"
-          $signedApk = "src-tauri/gen/android/app/build/outputs/apk/universal/release/cinny-release.apk"
-          $keystore = "$env:USERPROFILE\.android\debug.keystore"
-          
-          # Find Android SDK
-          $androidHome = if ($env:ANDROID_HOME) { $env:ANDROID_HOME } 
-                         elseif ($env:ANDROID_SDK_ROOT) { $env:ANDROID_SDK_ROOT }
-                         elseif (Test-Path "$env:LOCALAPPDATA\Android\Sdk") { "$env:LOCALAPPDATA\Android\Sdk" }
-                         else { "$env:USERPROFILE\AppData\Local\Android\Sdk" }
-          
-          Write-Host "Using Android SDK at: $androidHome"
-          
-          # Use debug keystore for signing (create if missing)
-          if (-not (Test-Path $keystore)) {
-            keytool -genkey -v -keystore $keystore -storepass android -alias androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=Android Debug,O=Android,C=US"
-          }
-          
-          # Find build tools
-          $buildTools = Get-ChildItem "$androidHome\build-tools" | Sort-Object Name -Descending | Select-Object -First 1
-          $apksigner = "$($buildTools.FullName)\apksigner.bat"
-          $zipalign = "$($buildTools.FullName)\zipalign.exe"
-          
-          Write-Host "Using build tools: $($buildTools.FullName)"
-          
-          # Align the APK
-          & $zipalign -v -p 4 $unsignedApk "$unsignedApk.aligned"
-          
-          # Sign the APK
-          & $apksigner sign --ks $keystore --ks-pass pass:android --key-pass pass:android --out $signedApk "$unsignedApk.aligned"
-          
-          # Verify
-          & $apksigner verify $signedApk
-          
-          Write-Host "Signed APK created at: $signedApk"
-          
-          # Rename to final name
-          Copy-Item $signedApk "src-tauri/gen/android/app/build/outputs/apk/universal/release/Cinny-Android.apk"
-      
-      - name: Upload APK
-        uses: actions/upload-artifact@v3
-        with:
-          name: Cinny-Android.apk
-          path: src-tauri/gen/android/app/build/outputs/apk/universal/release/Cinny-Android.apk
+          name: latest-linux.yml
+          path: dist-electron/latest-linux.yml
 
   create-release:
     runs-on: ubuntu-latest
-    needs: [build-windows, build-linux, build-android]
-    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [increment-version, build-windows, build-linux]
+    if: always() && (needs.build-windows.result == 'success' || needs.build-linux.result == 'success')
     
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.ref_name }}
+      
+      - name: Pull latest (after version bump)
+        if: github.ref == 'refs/heads/main'
+        run: git pull origin main
+      
+      - name: Get version
+        id: version
+        run: |
+          # Use version from increment-version job if available, otherwise read from file
+          if [ -n "${{ needs.increment-version.outputs.version }}" ]; then
+            VERSION="${{ needs.increment-version.outputs.version }}"
+          else
+            VERSION=$(grep -Po '"version":\s*"\K[^"]+' package.json | head -1)
+          fi
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          echo "Version: $VERSION"
+      
+      - name: Check if tag exists
+        id: tag_check
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+          if git rev-parse "v$VERSION" >/dev/null 2>&1; then
+            echo "Tag v$VERSION already exists"
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "Tag v$VERSION does not exist"
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+      
+      - name: Create and push tag
+        if: steps.tag_check.outputs.exists == 'false'
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+          git tag -a "v${{ steps.version.outputs.VERSION }}" -m "Release v${{ steps.version.outputs.VERSION }}"
+          git push origin "v${{ steps.version.outputs.VERSION }}"
       
       - name: Download all artifacts
         uses: actions/download-artifact@v3
         with:
           path: artifacts
       
-      - name: Get version from tag
-        id: version
-        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
-      
-      - name: Create update.json
-        run: |
-          VERSION="${{ steps.version.outputs.VERSION }}"
-          APPIMAGE_SIG=""
-          if [ -f "artifacts/Cinny-Linux-x64.AppImage.sig/Cinny-Linux-x64.AppImage.sig" ]; then
-            APPIMAGE_SIG=$(cat "artifacts/Cinny-Linux-x64.AppImage.sig/Cinny-Linux-x64.AppImage.sig")
-          fi
-          
-          cat > update.json << EOF
-          {
-            "version": "${VERSION}",
-            "notes": "Update to version ${VERSION}",
-            "pub_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-            "platforms": {
-              "linux-x86_64": {
-                "signature": "${APPIMAGE_SIG}",
-                "url": "http://synbox.ruv.wtf:8418/litruv/cinny-desktop/releases/download/v${VERSION}/Cinny-Linux-x64.AppImage"
-              }
-            }
-          }
-          EOF
-          cat update.json
-      
       - name: Prepare release files
         run: |
           mkdir -p release-files
-          # Move artifacts out of subdirectories
-          find artifacts -type f \( -name "*.msi" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.rpm" -o -name "*.apk" -o -name "*.sig" \) -exec cp {} release-files/ \;
-          cp update.json release-files/
+          find artifacts -type f \( -name "*.exe" -o -name "*.AppImage" -o -name "*.yml" \) -exec cp {} release-files/ \;
           ls -la release-files/
       
-      - name: Create Release
-        uses: softprops/action-gh-release@v1
-        with:
-          files: release-files/*
-          draft: false
-          prerelease: false
-          generate_release_notes: true
+      - name: Create or Update Release
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+          TAG_NAME="v${VERSION}"
+          API_BASE="http://synbox.ruv.wtf:8418/api/v1"
+          REPO="litruv/cinny-desktop"
+          
+          # Delete old releases (keep only current)
+          echo "Cleaning up old releases..."
+          OLD_RELEASES=$(curl -s -H "Authorization: token ${GITEA_TOKEN}" \
+            "${API_BASE}/repos/${REPO}/releases" | jq -r '.[] | select(.tag_name != "'${TAG_NAME}'") | .id')
+          
+          for OLD_ID in $OLD_RELEASES; do
+            echo "Deleting old release ${OLD_ID}..."
+            OLD_TAG=$(curl -s -H "Authorization: token ${GITEA_TOKEN}" \
+              "${API_BASE}/repos/${REPO}/releases/${OLD_ID}" | jq -r '.tag_name')
+            
+            # Delete release
+            curl -s -X DELETE -H "Authorization: token ${GITEA_TOKEN}" \
+              "${API_BASE}/repos/${REPO}/releases/${OLD_ID}"
+            
+            # Delete tag
+            if [ -n "$OLD_TAG" ]; then
+              echo "Deleting old tag ${OLD_TAG}..."
+              curl -s -X DELETE -H "Authorization: token ${GITEA_TOKEN}" \
+                "${API_BASE}/repos/${REPO}/tags/${OLD_TAG}"
+            fi
+          done
+          
+          # Check if release exists
+          RELEASE_ID=$(curl -s -H "Authorization: token ${GITEA_TOKEN}" \
+            "${API_BASE}/repos/${REPO}/releases/tags/${TAG_NAME}" | jq -r '.id // empty')
+          
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Creating new release for ${TAG_NAME}..."
+            RELEASE_ID=$(curl -s -X POST \
+              -H "Authorization: token ${GITEA_TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\": \"${TAG_NAME}\", \"name\": \"Release ${TAG_NAME}\", \"body\": \"Release ${VERSION}\", \"draft\": false, \"prerelease\": false}" \
+              "${API_BASE}/repos/${REPO}/releases" | jq -r '.id')
+            echo "Created release with ID: ${RELEASE_ID}"
+          else
+            echo "Release exists with ID: ${RELEASE_ID}"
+            # Delete existing assets
+            echo "Deleting existing assets..."
+            ASSETS=$(curl -s -H "Authorization: token ${GITEA_TOKEN}" \
+              "${API_BASE}/repos/${REPO}/releases/${RELEASE_ID}/assets" | jq -r '.[].id')
+            for ASSET_ID in $ASSETS; do
+              echo "Deleting asset ${ASSET_ID}..."
+              curl -s -X DELETE -H "Authorization: token ${GITEA_TOKEN}" \
+                "${API_BASE}/repos/${REPO}/releases/${RELEASE_ID}/assets/${ASSET_ID}"
+            done
+          fi
+          
+          # Upload new assets
+          echo "Uploading assets..."
+          for FILE in release-files/*; do
+            FILENAME=$(basename "$FILE")
+            echo "Uploading ${FILENAME}..."
+            curl -s -X POST \
+              -H "Authorization: token ${GITEA_TOKEN}" \
+              -H "Content-Type: application/octet-stream" \
+              --data-binary "@${FILE}" \
+              "${API_BASE}/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${FILENAME}"
+            echo ""
+          done
+          
+          echo "Release complete!"
+      
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GHTOKEN }}
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+          TAG_NAME="v${VERSION}"
+          GITHUB_REPO="Paarrot/Paarrot-Desktop"
+          
+          # Delete old GitHub releases (keep only current)
+          echo "Cleaning up old GitHub releases..."
+          OLD_RELEASES=$(curl -s -H "Authorization: token ${GH_TOKEN}" \
+            "https://api.github.com/repos/${GITHUB_REPO}/releases" | jq -r '.[] | select(.tag_name != "'${TAG_NAME}'") | .id')
+          
+          for OLD_ID in $OLD_RELEASES; do
+            echo "Deleting old GitHub release ${OLD_ID}..."
+            OLD_TAG=$(curl -s -H "Authorization: token ${GH_TOKEN}" \
+              "https://api.github.com/repos/${GITHUB_REPO}/releases/${OLD_ID}" | jq -r '.tag_name')
+            
+            # Delete release
+            curl -s -X DELETE -H "Authorization: token ${GH_TOKEN}" \
+              "https://api.github.com/repos/${GITHUB_REPO}/releases/${OLD_ID}"
+            
+            # Delete tag
+            if [ -n "$OLD_TAG" ]; then
+              echo "Deleting old GitHub tag ${OLD_TAG}..."
+              curl -s -X DELETE -H "Authorization: token ${GH_TOKEN}" \
+                "https://api.github.com/repos/${GITHUB_REPO}/git/refs/tags/${OLD_TAG}"
+            fi
+          done
+          
+          # Check if release exists on GitHub
+          RELEASE_ID=$(curl -s -H "Authorization: token ${GH_TOKEN}" \
+            "https://api.github.com/repos/${GITHUB_REPO}/releases/tags/${TAG_NAME}" | jq -r '.id // empty')
+          
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Creating new GitHub release for ${TAG_NAME}..."
+            RELEASE_ID=$(curl -s -X POST \
+              -H "Authorization: token ${GH_TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\": \"${TAG_NAME}\", \"name\": \"Release ${TAG_NAME}\", \"body\": \"Release ${VERSION}\", \"draft\": false, \"prerelease\": false}" \
+              "https://api.github.com/repos/${GITHUB_REPO}/releases" | jq -r '.id')
+            echo "Created GitHub release with ID: ${RELEASE_ID}"
+          else
+            echo "GitHub release exists with ID: ${RELEASE_ID}"
+          fi
+          
+          # Upload assets to GitHub
+          echo "Uploading assets to GitHub..."
+          UPLOAD_URL=$(curl -s -H "Authorization: token ${GH_TOKEN}" \
+            "https://api.github.com/repos/${GITHUB_REPO}/releases/${RELEASE_ID}" | jq -r '.upload_url' | sed 's/{?name,label}//')
+          
+          for FILE in release-files/*; do
+            FILENAME=$(basename "$FILE")
+            echo "Uploading ${FILENAME} to GitHub..."
+            curl -s -X POST \
+              -H "Authorization: token ${GH_TOKEN}" \
+              -H "Content-Type: application/octet-stream" \
+              --data-binary "@${FILE}" \
+              "${UPLOAD_URL}?name=${FILENAME}"
+            echo ""
+          done
+          
+          echo "GitHub release complete!"

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-github: ajbura
-liberapay: ajbura
-open_collective: cinny

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,58 +0,0 @@
-name: 🐞 Bug Report
-description: Report a bug
-labels: 'type: bug'
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## First of all
-        1. Please search for [existing issues](https://github.com/cinnyapp/cinny-desktop/issues?q=is%3Aissue) about this problem first.
-        2. Make sure Cinny is up to date.
-        3. Make sure it's an issue with Cinny and not something else you are using.
-        4. Remember to be friendly.
-
-  - type: textarea
-    id: description
-    attributes:
-      label: Describe the bug
-      description: A clear description of what the bug is. Include screenshots if applicable.
-      placeholder: Bug description
-    validations:
-      required: true
-
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: Reproduction
-      description: Steps to reproduce the behavior.
-      placeholder: |
-        1. Go to ...
-        2. Click on ...
-        3. See error
-
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: Expected behavior
-      description: A clear description of what you expected to happen.
-
-  - type: textarea
-    id: info
-    attributes:
-      label: Platform and versions
-      description: "Provide OS, browser and Cinny version with your Homeserver."
-      placeholder: |
-       1. OS: [e.g. Windows 10, MacOS]
-       2. Cinny version: [e.g. 1.8.1]
-       3. Matrix homeserver: [e.g. matrix.org]
-       4. Downloaded from: [e.g. GitHub, Flatpak]
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: context
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +0,0 @@
-contact_links:
-  - name: 💬 Matrix Chat
-    url: https://matrix.to/#/#cinny:matrix.org
-    about: Ask questions and talk to other Cinny users and the maintainers

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,34 +0,0 @@
-name: 💡 Feature Request
-description: Suggest an idea
-labels: 'type: feature'
-
-body:
-  - type: textarea
-    id: problem
-    attributes:
-      label: Describe the problem
-      description: A clear description of the problem this feature would solve
-      placeholder: "I'm always frustrated when..."
-    validations:
-      required: true
-
-  - type: textarea
-    id: solution
-    attributes:
-      label: "Describe the solution you'd like"
-      description: A clear description of what change you would like
-      placeholder: "I would like to..."
-    validations:
-      required: true
-
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives considered
-      description: "Any alternative solutions you've considered"
-
-  - type: textarea
-    id: context
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,22 +0,0 @@
-<!-- Please read https://github.com/cinnyapp/cinny/blob/dev/CONTRIBUTING.md before submitting your pull request -->
-
-### Description
-<!-- Please include a summary of the change. Please also include relevant motivation and context. List any dependencies that are required for this change. -->
-
-
-Fixes #
-
-#### Type of change
-
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] This change requires a documentation update
-
-### Checklist:
-
-- [ ] My code follows the style guidelines of this project
-- [ ] I have performed a self-review of my own code
-- [ ] I have commented my code, particularly in hard-to-understand areas
-- [ ] I have made corresponding changes to the documentation
-- [ ] My changes generate no new warnings

.github/SECURITY.md

@@ -1,3 +0,0 @@
-# Reporting a Vulnerability
-
-**If you've found a security vulnerability, please report it to cinnyapp@gmail.com**

.github/dependabot.yml

@@ -1,30 +0,0 @@
-# Docs: <https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/customizing-dependency-updates>
-
-version: 2
-updates:
-#   - package-ecosystem: npm
-#     directory: /
-#     schedule:
-#       interval: weekly
-#       day: "tuesday"
-#       time: "01:00"
-#       timezone: "Asia/Kolkata"
-#     open-pull-requests-limit: 15
-
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: weekly
-      day: "tuesday"
-      time: "01:00"
-      timezone: "Asia/Kolkata"
-    open-pull-requests-limit: 5
-
-#   - package-ecosystem: cargo
-#     directory: /src-tauri/
-#     schedule:
-#       interval: weekly
-#       day: "tuesday"
-#       time: "01:00"
-#       timezone: "Asia/Kolkata"
-#     open-pull-requests-limit: 5

.github/renovate.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "config:recommended",
-    ":dependencyDashboardApproval"
-  ],
-  "labels": [
-    "Dependencies"
-  ],
-  "packageRules": [
-    {
-      "matchUpdateTypes": [
-        "lockFileMaintenance"
-      ]
-    }
-  ],
-  "lockFileMaintenance": {
-    "enabled": true
-  },
-  "dependencyDashboard": true
-}

.github/workflows/archive.yml

@@ -1,22 +0,0 @@
-name: "Upload zip-archive"
-on:
-  release:
-    types: [published]
-
-jobs:
-  zip-archive:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.2.0
-        with:
-          submodules: true
-      - name: Create zip including submodules
-        run: |
-          cd ..
-          zip ${{ github.event.repository.name }}/${{ github.event.repository.name }}-${{ github.ref_name }}.zip ${{ github.event.repository.name }} -r
-      - name: Upload zip to release
-        uses: softprops/action-gh-release@6cbd405e2c4e67a21c47fa9e383d020e4e28b836
-        with:
-          files: |
-            ${{ github.event.repository.name }}-${{ github.ref_name }}.zip

.github/workflows/cla.yml

@@ -1,36 +0,0 @@
-name: 'CLA Assistant'
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, closed, synchronize]
-
-jobs:
-  CLAssistant:
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'CLA Assistant'
-        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
-        # Beta Release
-        uses: cla-assistant/github-action@v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # the below token should have repo scope and must be manually added by you in the repository's secret
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.CLA_PAT }}
-        with:
-          path-to-signatures: 'signatures.json'
-          path-to-document: 'https://github.com/cinnyapp/cla/blob/main/cla.md' # e.g. a CLA or a DCO document
-          # branch should not be protected
-          branch: 'main'
-          allowlist: ajbura,bot*
-
-          #below are the optional inputs - If the optional inputs are not given, then default values will be taken
-          remote-organization-name: cinnyapp
-          remote-repository-name: cla
-          #create-file-commit-message: 'For example: Creating file for storing CLA Signatures'
-          #signed-commit-message: 'For example: $contributorName has signed the CLA in #$pullRequestNo'
-          #custom-notsigned-prcomment: 'pull request comment with Introductory message to ask new contributors to sign'
-          #custom-pr-sign-comment: 'The signature to be committed in order to sign the CLA'
-          #custom-allsigned-prcomment: 'pull request comment when all contributors has signed, defaults to **CLA Assistant Lite bot** All Contributors have signed the CLA.'
-          #lock-pullrequest-aftermerge: false - if you don't want this bot to automatically lock the pull request after merging (default - true)
-          #use-dco-flag: true - If you are using DCO instead of CLA

.github/workflows/lockfile.yml

@@ -1,26 +0,0 @@
-name: NPM Lockfile Changes
-
-on:
-  pull_request:
-    paths:
-      - 'package-lock.json'
-
-jobs:
-  lockfile_changes:
-    runs-on: ubuntu-latest
-    # Permission overwrite is required for Dependabot PRs, see "Common issues" below.
-    permissions:
-      contents: read
-      pull-requests: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4.2.0
-      - name: NPM Lockfile Changes
-        uses: codepunkt/npm-lockfile-changes@b40543471c36394409466fdb277a73a0856d7891
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          # Optional inputs, can be deleted safely if you are happy with default values.
-          collapsibleThreshold: 25
-          failOnDowngrade: false
-          path: package-lock.json
-          updateComment: true

.github/workflows/tauri.yml

@@ -1,173 +0,0 @@
-name: "Publish Tauri App"
-on:
-  release:
-    types: [published]
-
-jobs:
-  # Windows-x86_64
-  windows-x86_64:
-    runs-on: windows-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.2.0
-        with: 
-          submodules: true
-      - name: Setup node
-        uses: actions/setup-node@v4.4.0
-        with:
-          node-version: 20.12.2
-          cache: 'npm'
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install cinny dependencies
-        run: cd cinny && npm ci
-      - name: Install tauri dependencies
-        run: npm ci
-      - name: Build desktop app with Tauri
-        uses: tauri-apps/tauri-action@v0.5.14
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          NODE_OPTIONS: "--max_old_space_size=4096"
-        with:
-          releaseId: ${{ github.event.release.upload_url }}
-      - name: Get app version (windows)
-        run: |
-          $json = (Get-Content "src-tauri\tauri.conf.json" -Raw) | ConvertFrom-Json
-          $version = $json.package.version
-          echo "Version: ${version}"
-          echo "TAURI_VERSION=${version}" >> $Env:GITHUB_ENV
-          echo "${Env:TAURI_VERSION}"
-        shell: pwsh
-      - name: Move msi
-        run: Move-Item "src-tauri\target\release\bundle\msi\Cinny_${{ env.TAURI_VERSION }}_x64_en-US.msi" "src-tauri\target\release\bundle\msi\Cinny_desktop-x86_64.msi"
-        shell: pwsh
-      - name: Move msi.zip
-        run: Move-Item "src-tauri\target\release\bundle\msi\Cinny_${{ env.TAURI_VERSION }}_x64_en-US.msi.zip" "src-tauri\target\release\bundle\msi\Cinny_desktop-x86_64.msi.zip"
-        shell: pwsh
-      - name: Move msi.zip.sig
-        run: Move-Item "src-tauri\target\release\bundle\msi\Cinny_${{ env.TAURI_VERSION }}_x64_en-US.msi.zip.sig" "src-tauri\target\release\bundle\msi\Cinny_desktop-x86_64.msi.zip.sig"
-        shell: pwsh
-      - name: Upload tagged release
-        uses: softprops/action-gh-release@6cbd405e2c4e67a21c47fa9e383d020e4e28b836
-        with:
-          files: |
-            src-tauri/target/release/bundle/msi/Cinny_desktop-x86_64.msi
-            src-tauri/target/release/bundle/msi/Cinny_desktop-x86_64.msi.zip
-            src-tauri/target/release/bundle/msi/Cinny_desktop-x86_64.msi.zip.sig
-
-  # Linux-x86_64
-  linux-x86_64:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.2.0
-        with: 
-          submodules: true
-      - name: Setup node
-        uses: actions/setup-node@v4.4.0
-        with:
-          node-version: 20.12.2
-          cache: 'npm'
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
-      - name: Install cinny dependencies
-        run: cd cinny && npm ci
-      - name: Install tauri dependencies
-        run: npm ci
-      - name: Build desktop app with Tauri
-        uses: tauri-apps/tauri-action@v0.5.14
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          NODE_OPTIONS: "--max_old_space_size=4096"
-        with:
-          releaseId: ${{ github.event.release.upload_url }}
-      - name: Get app version
-        id: vars
-        run: echo "tag=$(jq .package.version src-tauri/tauri.conf.json | tr -d '"')" >> $GITHUB_OUTPUT
-      - name: Move deb
-        run: mv "src-tauri/target/release/bundle/deb/cinny_${{ steps.vars.outputs.tag }}_amd64.deb" "src-tauri/target/release/bundle/deb/Cinny_desktop-x86_64.deb"
-      - name: Move AppImage
-        run: mv "src-tauri/target/release/bundle/appimage/cinny_${{ steps.vars.outputs.tag }}_amd64.AppImage" "src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage"
-      - name: Move AppImage.tar.gz
-        run: mv "src-tauri/target/release/bundle/appimage/cinny_${{ steps.vars.outputs.tag }}_amd64.AppImage.tar.gz" "src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage.tar.gz"
-      - name: Move AppImage.tar.gz.sig
-        run: mv "src-tauri/target/release/bundle/appimage/cinny_${{ steps.vars.outputs.tag }}_amd64.AppImage.tar.gz.sig" "src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage.tar.gz.sig"
-      - name: Upload tagged release
-        uses: softprops/action-gh-release@6cbd405e2c4e67a21c47fa9e383d020e4e28b836
-        with:
-          files: |
-            src-tauri/target/release/bundle/deb/Cinny_desktop-x86_64.deb
-            src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage
-            src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage.tar.gz
-            src-tauri/target/release/bundle/appimage/Cinny_desktop-x86_64.AppImage.tar.gz.sig
-
-  # macos-universal
-  macos-universal:
-    runs-on: macos-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.2.0
-        with: 
-          submodules: true
-      - name: Setup node
-        uses: actions/setup-node@v4.4.0
-        with:
-          node-version: 20.12.2
-          cache: 'npm'
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          target: aarch64-apple-darwin,x86_64-apple-darwin
-      - name: Install cinny dependencies
-        run: cd cinny && npm ci
-      - name: Install tauri dependencies
-        run: npm ci
-      - name: Build desktop app with Tauri
-        uses: tauri-apps/tauri-action@v0.5.14
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          NODE_OPTIONS: "--max_old_space_size=4096"
-        with:
-          releaseId: ${{ github.event.release.upload_url }}
-          args: "--target universal-apple-darwin"
-      - name: Get app version
-        id: vars
-        run: echo "tag=$(jq .package.version src-tauri/tauri.conf.json | tr -d '"')" >> $GITHUB_OUTPUT
-      - name: Move dmg
-        run: mv "src-tauri/target/universal-apple-darwin/release/bundle/dmg/Cinny_${{ steps.vars.outputs.tag }}_universal.dmg" "src-tauri/target/universal-apple-darwin/release/bundle/dmg/Cinny_desktop-universal.dmg"
-      - name: Move app.tar.gz
-        run: mv "src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny.app.tar.gz" "src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny_desktop-universal.app.tar.gz"
-      - name: Move app.tar.gz.sig
-        run: mv "src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny.app.tar.gz.sig" "src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny_desktop-universal.app.tar.gz.sig"
-      - name: Upload tagged release
-        uses: softprops/action-gh-release@6cbd405e2c4e67a21c47fa9e383d020e4e28b836
-        with:
-          files: |
-            src-tauri/target/universal-apple-darwin/release/bundle/dmg/Cinny_desktop-universal.dmg
-            src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny_desktop-universal.app.tar.gz
-            src-tauri/target/universal-apple-darwin/release/bundle/macos/Cinny_desktop-universal.app.tar.gz.sig
-
-  # Upload release.json
-  release-update:
-    if: always()
-    needs: [windows-x86_64, linux-x86_64, macos-universal]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4.2.0
-      - name: Install dependencies
-        run: npm ci
-      - name: Run release.json
-        run: npm run release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,40 +0,0 @@
-name: "Build pull request"
-on:
-  #pull_request:
-    #types: ['opened', 'synchronize']
-
-jobs:
-  publish-tauri:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [macos-latest, ubuntu-20.04, windows-latest]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4.2.0
-      with: 
-        submodules: true
-    - name: Setup node
-      uses: actions/setup-node@v4.4.0
-      with:
-        node-version: 20.12.2
-        cache: 'npm'
-    - name: Install Rust stable
-      uses: actions-rs/toolchain@v1.0.7
-      with:
-        toolchain: stable
-    - name: Install dependencies (ubuntu only)
-      if: matrix.platform == 'ubuntu-20.04'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
-    - name: Install cinny dependencies
-      run: cd cinny && npm ci
-    - name: Install tauri dependencies
-      run: npm ci
-    - name: Build desktop app with Tauri
-      uses: tauri-apps/tauri-action@v0.5.14
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -4,3 +4,4 @@ node_modules
 devAssets
 
 .DS_Store
+dist-electron/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "liveServer.settings.port": 5501
+}

README.md

@@ -1,39 +1,78 @@
-# Cinny desktop
-
-<a href="https://github.com/cinnyapp/cinny-desktop/releases">
-  <img alt="GitHub release downloads" src="https://img.shields.io/github/downloads/cinnyapp/cinny-desktop/total?style=social"></a>
-
-Cinny is a matrix client focusing primarily on simple, elegant and secure interface. The desktop app is made with Tauri.
+# Paarrot 
 
+Paarrot is a Matrix client focusing primarily on simple, elegant and secure interface. The desktop app is built with Electron and based on Cinny.
+ 
 ## Download
 
-Installers for macOS, Windows and Linux can be downloaded from [Github releases](https://github.com/cinnyapp/cinny-desktop/releases). Releases are signed with a [Ed25519](https://ed25519.cr.yp.to/) public-key.
-
+Installers for Windows and Linux can be downloaded from [releases](http://synbox.ruv.wtf:8418/litruv/cinny-desktop/releases).
+ 
 Operating System | Download
 ---|---
-Windows | <a href='https://github.com/cinnyapp/cinny-desktop/releases/latest/download/Cinny_desktop-x86_64.msi'>Get it on Windows</a>
-macOS | <a href='https://github.com/cinnyapp/cinny-desktop/releases/latest/download/Cinny_desktop-universal.dmg'>Get it on macOS</a>
-Linux | <a href='https://github.com/cinnyapp/cinny-desktop/releases/latest/download/Cinny_desktop-x86_64.AppImage'>Get it on Linux</a> · <a href='https://flathub.org/apps/details/in.cinny.Cinny'>Flatpak</a>
+Windows (x64) | <a href='http://synbox.ruv.wtf:8418/litruv/cinny-desktop/releases'>Get it on Windows</a>
+Linux (AppImage) | <a href='http://synbox.ruv.wtf:8418/litruv/cinny-desktop/releases'>Get it on Linux</a>
 
-Decoded public key:
-> RWRflTUQD3RHFtn25QNANCmePR9+4LSK89kAKTMEEB4OKpOFpLMgc64z
+### Linux Installation
 
-To verify release files, you need to download [minisign](https://jedisct1.github.io/minisign/) tool and [decode](https://www.base64decode.org/) the *.sig* file before running:
->  minisign -Vm ***RELEASE_FILE.msi.zip*** -P RWRflTUQD3RHFtn25QNANCmePR9+4LSK89kAKTMEEB4OKpOFpLMgc64z -x ***SINGATURE.msi.zip.sig***
+For the best AppImage experience, we recommend using [AppImageLauncher](https://github.com/TheAssassin/AppImageLauncher) which automatically integrates AppImages into your system.
 
 ## Local development
 
-Firstly, to setup Rust, NodeJS and build tools follow [Tauri documentation](https://tauri.app/v1/guides/getting-started/prerequisites).
-
-Now, to setup development locally run the following commands:
-* `git clone --recursive https://github.com/cinnyapp/cinny-desktop.git`
+To setup development locally run the following commands:
+* `git clone --recursive http://synbox.ruv.wtf:8418/litruv/cinny-desktop.git`
 * `cd cinny-desktop/cinny`
 * `npm ci`
 * `cd ..`
-* `npm ci`
+* `npm ci` 
 
 To build the app locally, run:
-* `npm run tauri build`
+* `npm run build`
 
 To start local dev server, run:
-* `npm run tauri dev`
+* `npm run dev`
+
+## Plugin System
+
+Paarrot includes a plugin system for extending and customising the app with JavaScript modules.
+
+### Installing Plugins
+
+1. Drop a plugin folder into your plugins directory:
+   - **Windows**: `%APPDATA%\paarrot\plugins\<plugin-name>\`
+   - **Linux**: `~/.config/Paarrot/plugins/<plugin-name>/`
+   - **macOS**: `~/Library/Application Support/Paarrot/plugins/<plugin-name>/`
+2. Enable it in **Settings → Plugins → Installed**
+
+### What Plugins Can Do
+
+- Register custom slash commands
+- Intercept and modify messages
+- Inject buttons into 11 UI locations (nav lists, toolbars, headers, sidebar, menus)
+- Register custom themes
+- Hook into raw Matrix events
+- Run background tasks
+- Show system notifications
+
+### Plugin Locations (UI Buttons)
+
+Plugins can inject buttons as **nav list rows** or **icon buttons** across the app:
+
+| Location | Style | Where |
+|---|---|---|
+| `channel-list` | Nav row | Space channel list |
+| `home-section` | Nav row | Home panel, above room list |
+| `direct-messages` | Nav row | DMs panel, below "Create Chat" |
+| `sidebar-actions` | Icon | Left sidebar — above Explore and above Search |
+| `text-composer-toolbar` | Icon | Message composer toolbar |
+| `composer-actions` | Icon | Beside the `+` attach button |
+| `room-header` | Icon | Room header bar |
+| `room-menu` | Icon | Room ⋮ dropdown |
+| `message-actions` | Icon | Message hover bar |
+| `user-menu` | Icon | Right-click on user avatar |
+| `search-notification-section` | Icon | Notifications page header |
+
+### Documentation
+
+- [Plugin System Overview](PLUGINS.md)
+- [Full Plugin API Reference](docs/PLUGIN_API.md)
+- [Button Registration API](docs/PLUGIN_BUTTON_API.md)
+- [Example Plugins](plugins/)

build-and-publish.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Set GitHub token for publishing
+export GH_TOKEN="ghtoken"
+
+# Run the build and publish
+npm run build
+
+# Exit with the build's exit code
+exit $?

build-resources/linux/after-install.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Post-installation script for .deb and .rpm packages
+
+# Update desktop database for the .desktop file 
+if command -v update-desktop-database &> /dev/null; then
+    update-desktop-database -q /usr/share/applications || true
+fi
+
+# Update icon cache
+if command -v gtk-update-icon-cache &> /dev/null; then
+    gtk-update-icon-cache -q -t -f /usr/share/icons/hicolor || true
+fi
+
+# Set appropriate permissions for chrome-sandbox (required for Electron)
+SANDBOX_PATH="/opt/Paarrot/chrome-sandbox"
+if [ -f "$SANDBOX_PATH" ]; then
+    chmod 4755 "$SANDBOX_PATH" || true
+fi
+
+exit 0

build-resources/linux/after-remove.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Post-removal script for .deb and .rpm packages
+
+# Update desktop database after removal
+if command -v update-desktop-database &> /dev/null; then
+    update-desktop-database -q /usr/share/applications || true
+fi
+
+# Update icon cache
+if command -v gtk-update-icon-cache &> /dev/null; then
+    gtk-update-icon-cache -q -t -f /usr/share/icons/hicolor || true
+fi
+
+exit 0

config.json

@@ -9,30 +9,13 @@
     "xmr.se"
   ],
   "allowCustomHomeservers": true,
-
-  "calling": {
-    "livekitServiceUrl": "https://b.ruv.wtf/matrix-rtc/livekit/jwt"
-  },
-
   "featuredCommunities": {
     "openAsDefault": false,
     "spaces": [
-      "#cinny-space:matrix.org",
-      "#community:matrix.org",
-      "#space:envs.net",
-      "#science-space:matrix.org",
-      "#libregaming-games:tchncs.de",
-      "#mathematics-on:matrix.org"
     ],
     "rooms": [
-      "#cinny:matrix.org",
-      "#freesoftware:matrix.org",
-      "#pcapdroid:matrix.org",
-      "#gentoo:matrix.org",
-      "#PrivSec.dev:arcticfoxes.net",
-      "#disroot:aria-net.org"
     ],
-    "servers": ["envs.net", "matrix.org", "monero.social", "mozilla.org"]
+    "servers": []
   },
 
   "hashRouter": {

dev-app-update.yml

@@ -0,0 +1,4 @@
+provider: github
+owner: Paarrot
+repo: Paarrot-Desktop
+updaterCacheDirName: paarrot-updater

electron-builder.json5

@@ -0,0 +1,107 @@
+{
+  "appId": "com.paarrot.app",
+  "productName": "Paarrot",
+  "artifactName": "${productName}-${version}-${os}-${arch}.${ext}",
+  "copyright": "Copyright © 2026 Mates.Media",
+  "directories": {
+    "output": "dist-electron",
+    "buildResources": "build-resources"
+  },
+  "files": [
+    "electron/**/*",
+    "cinny/dist/**/*",
+    "dev-app-update.yml",
+    "!**/*.map",
+    "!**/node_modules/*/{CHANGELOG.md,README.md,README,readme.md,readme}",
+    "!**/node_modules/*/{test,__tests__,tests,powered-test,example,examples}",
+    "!**/node_modules/*.d.ts",
+    "!**/node_modules/.bin",
+    "!**/*.{iml,o,hprof,orig,pyc,pyo,rbc,swp,csproj,sln,xproj}",
+    "!.editorconfig",
+    "!**/._*",
+    "!**/{.DS_Store,.git,.hg,.svn,CVS,RCS,SCCS,.gitignore,.gitattributes}",
+    "!**/{__pycache__,thumbs.db,.flowconfig,.idea,.vs,.nyc_output}",
+    "!**/{appveyor.yml,.travis.yml,circle.yml}",
+    "!**/{npm-debug.log,yarn.lock,.yarn-integrity,.yarn-metadata.json}"
+  ],
+  "extraResources": [
+    {
+      "from": "icons",
+      "to": "icons",
+      "filter": ["**/*"]
+    },
+    {
+      "from": "cinny/public/sound",
+      "to": "sound",
+      "filter": ["**/*"]
+    }
+  ],
+  "linux": {
+    "target": [
+      {
+        "target": "AppImage",
+        "arch": ["x64"]
+      }
+    ],
+    "category": "Network;InstantMessaging",
+    "maintainer": "Mates.Media <mates.media@users.noreply.github.com>",
+    "icon": "icons/icon.png",
+    "desktop": {
+      "entry": {
+        "Name": "Paarrot",
+        "GenericName": "Matrix Client",
+        "Comment": "A Matrix client built with Cinny",
+        "Categories": "Network;InstantMessaging;",
+        "Keywords": "matrix;chat;messaging;",
+        "StartupWMClass": "paarrot"
+      }
+    }
+  },
+  "deb": {
+    "depends": [
+      "libnotify4",
+      "libxtst6",
+      "libnss3"
+    ],
+    "afterInstall": "build-resources/linux/after-install.sh",
+    "afterRemove": "build-resources/linux/after-remove.sh"
+  },
+  "rpm": {
+    "depends": [
+      "libnotify",
+      "libXtst",
+      "nss"
+    ],
+    "afterInstall": "build-resources/linux/after-install.sh",
+    "afterRemove": "build-resources/linux/after-remove.sh"
+  },
+  "win": {
+    "target": [
+      {
+        "target": "nsis",
+        "arch": ["x64"]
+      }
+    ],
+    "icon": "icons/icon.ico",
+    "artifactName": "${productName}-${version}-${os}-${arch}.${ext}"
+  },
+  "nsis": {
+    "oneClick": true,
+    "perMachine": false,
+    "allowToChangeInstallationDirectory": false,
+    "deleteAppDataOnUninstall": false,
+    "createDesktopShortcut": true,
+    "createStartMenuShortcut": true,
+    "shortcutName": "Paarrot",
+    "differentialPackage": false
+  },
+  "compression": "normal",
+  "publish": [
+    {
+      "provider": "github",
+      "owner": "Paarrot",
+      "repo": "Paarrot-Desktop",
+      "releaseType": "release"
+    }
+  ]
+}

electron/api-server.js

@@ -0,0 +1,267 @@
+const express = require('express');
+const cors = require('cors');
+const bodyParser = require('body-parser');
+
+class PaarrotAPIServer {
+  constructor(mainWindow) {
+    this.mainWindow = mainWindow;
+    this.app = express();
+    this.server = null;
+    this.port = 33384; // Default port for Paarrot API
+    
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    // Enable CORS for all origins (you can restrict this if needed)
+    this.app.use(cors());
+    
+    // Parse JSON bodies
+    this.app.use(bodyParser.json());
+    
+    // Log all requests
+    this.app.use((req, res, next) => {
+      console.log(`Paarrot API: ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  setupRoutes() {
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({ status: 'ok', app: 'Paarrot API', version: '1.0.0' });
+    });
+
+    // Get current status
+    this.app.get('/status', async (req, res) => {
+      try {
+        const status = await this.executeAction('get-status');
+        res.json({ success: true, data: status });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Mute/unmute
+    this.app.post('/mute', async (req, res) => {
+      try {
+        const { muted } = req.body;
+        const result = await this.executeAction('set-mute', { muted });
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Toggle mute
+    this.app.post('/mute/toggle', async (req, res) => {
+      try {
+        const result = await this.executeAction('toggle-mute');
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Deafen/undeafen
+    this.app.post('/deafen', async (req, res) => {
+      try {
+        const { deafened } = req.body;
+        const result = await this.executeAction('set-deafen', { deafened });
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Toggle deafen
+    this.app.post('/deafen/toggle', async (req, res) => {
+      try {
+        const result = await this.executeAction('toggle-deafen');
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Change channel/room
+    this.app.post('/channel', async (req, res) => {
+      try {
+        const { roomId } = req.body;
+        if (!roomId) {
+          return res.status(400).json({ success: false, error: 'roomId is required' });
+        }
+        const result = await this.executeAction('change-channel', { roomId });
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Get list of rooms/channels
+    this.app.get('/channels', async (req, res) => {
+      try {
+        const result = await this.executeAction('get-channels');
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Send message
+    this.app.post('/message', async (req, res) => {
+      try {
+        const { roomId, message } = req.body;
+        if (!roomId || !message) {
+          return res.status(400).json({ 
+            success: false, 
+            error: 'roomId and message are required' 
+          });
+        }
+        const result = await this.executeAction('send-message', { roomId, message });
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Send message to current room
+    this.app.post('/message/current', async (req, res) => {
+      try {
+        const { message } = req.body;
+        if (!message) {
+          return res.status(400).json({ 
+            success: false, 
+            error: 'message is required' 
+          });
+        }
+        const result = await this.executeAction('send-message-current', { message });
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Get current room info
+    this.app.get('/room/current', async (req, res) => {
+      try {
+        const result = await this.executeAction('get-current-room');
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // 404 handler
+    this.app.use((req, res) => {
+      res.status(404).json({ 
+        success: false, 
+        error: 'Endpoint not found',
+        availableEndpoints: [
+          'GET /health',
+          'GET /status',
+          'POST /mute',
+          'POST /mute/toggle',
+          'POST /deafen',
+          'POST /deafen/toggle',
+          'POST /channel',
+          'GET /channels',
+          'POST /message',
+          'POST /message/current',
+          'GET /room/current'
+        ]
+      });
+    });
+
+    // Error handler
+    this.app.use((err, req, res, next) => {
+      console.error('Paarrot API Error:', err);
+      res.status(500).json({ success: false, error: err.message });
+    });
+  }
+
+  /**
+   * Execute an action by sending it to the renderer process
+   * @param {string} action - The action to execute
+   * @param {object} params - Parameters for the action
+   * @returns {Promise<any>} - Result from the renderer
+   */
+  executeAction(action, params = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this.mainWindow || this.mainWindow.isDestroyed()) {
+        return reject(new Error('Main window is not available'));
+      }
+
+      // Create a unique response channel
+      const responseChannel = `api-response-${Date.now()}-${Math.random()}`;
+      
+      // Set up one-time listener for the response
+      const { ipcMain } = require('electron');
+      const timeout = setTimeout(() => {
+        ipcMain.removeHandler(responseChannel);
+        reject(new Error('Action timed out'));
+      }, 10000); // 10 second timeout
+
+      ipcMain.handleOnce(responseChannel, async (event, result) => {
+        clearTimeout(timeout);
+        if (result.success) {
+          resolve(result.data);
+        } else {
+          reject(new Error(result.error || 'Unknown error'));
+        }
+      });
+
+      // Send the action to the renderer
+      this.mainWindow.webContents.send('api-action', {
+        action,
+        params,
+        responseChannel
+      });
+    });
+  }
+
+  start(port = this.port) {
+    return new Promise((resolve, reject) => {
+      this.server = this.app.listen(port, '127.0.0.1', () => {
+        console.log(`Paarrot API server listening on http://127.0.0.1:${port}`);
+        console.log('Available endpoints:');
+        console.log('  GET  /health');
+        console.log('  GET  /status');
+        console.log('  POST /mute');
+        console.log('  POST /mute/toggle');
+        console.log('  POST /deafen');
+        console.log('  POST /deafen/toggle');
+        console.log('  POST /channel');
+        console.log('  GET  /channels');
+        console.log('  POST /message');
+        console.log('  POST /message/current');
+        console.log('  GET  /room/current');
+        resolve(port);
+      }).on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          console.error(`Paarrot API: Port ${port} is already in use`);
+          reject(new Error(`Port ${port} is already in use`));
+        } else {
+          console.error('Paarrot API: Failed to start server:', err);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          console.log('Paarrot API server stopped');
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+module.exports = PaarrotAPIServer;

electron/preload.js

@@ -0,0 +1,183 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+// Map command names to Electron IPC channels
+const commandMap = {
+  'window_minimize': 'window:minimize',
+  'window_maximize': 'window:maximize',
+  'window_unmaximize': 'window:unmaximize',
+  'window_close': 'window:close',
+  'window_is_maximized': 'window:is-maximized',
+  'window_start_drag': 'window:start-drag',
+  'read_clipboard_image': 'read-clipboard-image',
+  'write_clipboard_text': 'write-clipboard-text',
+  'open_external_url': 'open-external-url',
+  'get_youtube_stream': 'get-youtube-stream',
+  'start_background_sync': 'start-background-sync',
+  'stop_background_sync': 'stop-background-sync',
+  'get_background_sync_state': 'get-background-sync-state',
+  'check_for_updates': 'check-for-updates',
+  'download_update': 'download-update',
+  'install_update': 'install-update',
+  'get_desktop_sources': 'get-desktop-sources'
+};
+
+// Shared invoke function for legacy API compatibility
+const invokeHandler = async (command, args = {}) => {
+  try {
+    const channel = commandMap[command] || command;
+    const result = await ipcRenderer.invoke(channel, args);
+
+    // Return response in expected format
+    if (result && result.success === false) {
+      throw new Error(result.error || 'Unknown error');
+    }
+
+    // For commands that return data in a 'data' field
+    if (result && result.data !== undefined) {
+      return result.data;
+    }
+
+    // For simple commands that just return success/failure
+    return result;
+  } catch (error) {
+    console.error(`[Electron IPC] Error invoking ${command}:`, error);
+    throw error;
+  }
+};
+
+// Expose protected methods that allow the renderer process to use
+// ipcRenderer without exposing the entire object
+contextBridge.exposeInMainWorld('__TAURI_INTERNALS__', {
+  // Legacy API compatibility layer for existing frontend code
+  metadata: {
+    currentVersion: {
+      version: '2.0.0',
+      platform: process.platform,
+      arch: process.arch
+    }
+  },
+  // Add invoke function for legacy plugins
+  invoke: invokeHandler,
+  // Add stub for transformCallback to prevent errors with legacy plugins
+  transformCallback: (callback) => {
+    return callback;
+  }
+});
+
+contextBridge.exposeInMainWorld('__TAURI__', {
+  // Core IPC invoke - legacy API
+  invoke: invokeHandler,
+
+  // Event listeners (if needed for future events)
+  listen: (event, handler) => {
+    const subscription = (_, ...args) => handler(...args);
+    ipcRenderer.on(event, subscription);
+    
+    // Return unsubscribe function
+    return () => {
+      ipcRenderer.removeListener(event, subscription);
+    };
+  }
+});
+
+// Also expose under electron namespace for direct Electron APIs
+contextBridge.exposeInMainWorld('electron', {
+  platform: process.platform,
+  arch: process.arch,
+  versions: process.versions,
+  
+  // Window controls
+  window: {
+    minimize: () => ipcRenderer.invoke('window:minimize'),
+    maximize: () => ipcRenderer.invoke('window:maximize'),
+    unmaximize: () => ipcRenderer.invoke('window:unmaximize'),
+    close: () => ipcRenderer.invoke('window:close'),
+    isMaximized: () => ipcRenderer.invoke('window:is-maximized'),
+    startDrag: () => ipcRenderer.invoke('window:start-drag'),
+    focus: () => ipcRenderer.invoke('window:focus'),
+    flashFrame: (flash = true) => ipcRenderer.invoke('window:flash-frame', flash)
+  },
+  
+  // Clipboard
+  clipboard: {
+    readImage: () => ipcRenderer.invoke('read-clipboard-image'),
+    writeText: (text) => ipcRenderer.invoke('write-clipboard-text', text)
+  },
+    // Audio
+  audio: {
+    playNotificationSound: (soundType = 'message') => ipcRenderer.invoke('play-notification-sound', soundType),
+    getSoundBaseUrl: () => ipcRenderer.invoke('get-sound-base-url'),
+  },
+    // External URLs
+  shell: {
+    openExternal: (url) => ipcRenderer.invoke('open-external-url', url)
+  },
+  
+  // YouTube
+  youtube: {
+    getStream: (url) => ipcRenderer.invoke('get-youtube-stream', url)
+  },
+  
+  // Background sync (stubs for desktop)
+  sync: {
+    start: (args) => ipcRenderer.invoke('start-background-sync', args),
+    stop: () => ipcRenderer.invoke('stop-background-sync'),
+    getState: () => ipcRenderer.invoke('get-background-sync-state')
+  },
+  
+  // Auto-updater
+  updater: {
+    checkForUpdates: () => ipcRenderer.invoke('check-for-updates'),
+    downloadAndInstallUpdate: () => ipcRenderer.invoke('download-and-install-update'),
+    onUpdateAvailable: (callback) => {
+      ipcRenderer.on('update-available', (_, info) => callback(info));
+    },
+    onUpdateDownloadProgress: (callback) => {
+      ipcRenderer.on('update-download-progress', (_, progress) => callback(progress));
+    },
+    onUpdateDownloaded: (callback) => {
+      ipcRenderer.on('update-downloaded', (_, info) => callback(info));
+    },
+    downloadUpdate: () => ipcRenderer.invoke('download-update'),
+    installUpdate: () => ipcRenderer.invoke('install-update'),
+  },
+  
+  // Desktop capturer (for screen sharing)
+  desktopCapturer: {
+    getSources: (opts) => ipcRenderer.invoke('get-desktop-sources', opts)
+  },
+  
+  // API action handler (for external API server)
+  api: {
+    onAction: (callback) => {
+      const handler = (_, data) => callback(data);
+      ipcRenderer.on('api-action', handler);
+      return () => ipcRenderer.removeListener('api-action', handler);
+    },
+    sendResponse: (channel, result) => {
+      ipcRenderer.invoke(channel, result);
+    }
+  },
+  
+  // Desktop notifications
+  notification: {
+    show: (options) => ipcRenderer.invoke('show-notification', options),
+    onNavigate: (callback) => {
+      const handler = (_, data) => callback(data);
+      ipcRenderer.on('notification:navigate', handler);
+      return () => ipcRenderer.removeListener('notification:navigate', handler);
+    }
+  },
+  
+  // Plugin management
+  plugins: {
+    getPath: () => ipcRenderer.invoke('plugin:get-path'),
+    download: (pluginId, downloadUrl, name) => ipcRenderer.invoke('plugin:download', { pluginId, downloadUrl, name }),
+    list: () => ipcRenderer.invoke('plugin:list'),
+    uninstall: (pluginId) => ipcRenderer.invoke('plugin:uninstall', pluginId),
+    readPluginCode: (pluginId) => ipcRenderer.invoke('plugin:read-code', pluginId)
+  }
+});
+
+// Preload script ready
+

example-plugin/index.js

@@ -0,0 +1,161 @@
+// Example plugin for Paarrot - Demonstrates all plugin API features
+// This plugin showcases commands, message interceptors, settings, logging, and more
+
+module.exports = {
+  name: "Example Plugin",
+  version: "2.0.0",
+  
+  /**
+   * Called when the plugin is loaded
+   * @param {PluginContext} ctx - The plugin context with access to all APIs
+   */
+  onLoad: async (ctx) => {
+    ctx.log('🎉 Example plugin is loading...');
+    
+    try {
+      // 1. Register commands with args
+      ctx.commands.register({
+        name: "shrug",
+        description: "Send a shrug emoji",
+        run: () => {
+          ctx.log('Shrug command executed');
+          return "¯\\_(ツ)_/¯";
+        }
+      });
+
+      ctx.commands.register({
+        name: "echo",
+        args: ["text"],
+        description: "Echo back your text",
+        run: ({ text }) => {
+          ctx.log('Echo command:', text);
+          return text || "Nothing to echo!";
+        }
+      });
+
+      ctx.commands.register({
+        name: "wave",
+        description: "Wave at someone",
+        args: ["name"],
+        run: ({ name }) => {
+          return `👋 Hey ${name || 'everyone'}!`;
+        }
+      });
+
+      // 2. Message interceptors
+      ctx.messages.onBeforeSend((msg) => {
+        // Auto-expand abbreviations
+        if (msg.content === "brb") {
+          msg.content = "be right back!";
+          ctx.log('Expanded brb to full phrase');
+        }
+        if (msg.content === "omw") {
+          msg.content = "on my way!";
+        }
+      });
+
+      ctx.messages.onReceive((msg) => {
+        // Log all received messages (for debugging)
+        ctx.log(`Received message in ${msg.roomId}:`, msg.content.substring(0, 50));
+      });
+
+      // 3. Define settings
+      ctx.settings.define({
+        autoShrug: {
+          type: "boolean",
+          label: "Auto Shrug",
+          description: "Automatically append ¯\\_(ツ)_/¯ to messages ending with '?'",
+          default: false
+        },
+        theme: {
+          type: "select",
+          label: "Plugin Theme",
+          description: "Choose your preferred theme",
+          options: [
+            { value: "dark", label: "Dark" },
+            { value: "light", label: "Light" },
+            { value: "purple", label: "Purple" }
+          ],
+          default: "dark"
+        },
+        customPrefix: {
+          type: "string",
+          label: "Custom Prefix",
+          description: "Prefix for plugin commands",
+          default: "[Plugin]"
+        }
+      });
+
+      // Use settings
+      const autoShrug = ctx.settings.get('autoShrug');
+      if (autoShrug) {
+        ctx.log('Auto shrug is enabled!');
+        ctx.messages.onBeforeSend((msg) => {
+          if (msg.content.endsWith('?')) {
+            msg.content += ' ¯\\_(ツ)_/¯';
+          }
+        });
+      }
+
+      // 4. Listen to raw Matrix events
+      ctx.matrix.on('Room.timeline', (event) => {
+        if (event.getType() === 'm.room.message') {
+          const content = event.getContent();
+          if (content.body?.includes('hello')) {
+            ctx.log('Someone said hello!');
+          }
+        }
+      });
+
+      // 5. Background tasks
+      ctx.timers.setInterval(() => {
+        ctx.log('Background task running... (every 30s)');
+        // You could check for notifications, clean up data, etc.
+      }, 30000);
+
+      // 6. Notifications
+      ctx.notify({
+        title: "Example Plugin",
+        body: "Plugin loaded successfully!",
+        type: "success"
+      });
+
+      // 7. Custom UI renderer (conceptual - would need UI integration)
+      ctx.ui.registerRenderer("custom-message", (msg) => {
+        ctx.log('Rendering custom message:', msg);
+        // Return custom React component
+        return null;
+      });
+
+      // 8. Export API for other plugins
+      this.exports = {
+        greet: (name) => {
+          return `Hello, ${name}!`;
+        },
+        version: "2.0.0"
+      };
+
+      ctx.log('✅ Example plugin loaded successfully!');
+      ctx.log('Registered commands: /shrug, /echo, /wave');
+      ctx.log('Settings:', {
+        autoShrug: ctx.settings.get('autoShrug'),
+        theme: ctx.settings.get('theme'),
+        prefix: ctx.settings.get('customPrefix')
+      });
+      
+    } catch (error) {
+      ctx.error('Failed to load example plugin:', error);
+    }
+  },
+  
+  /**
+   * Called when the plugin is unloaded or disabled
+   */
+  onUnload: async () => {
+    console.log('[ExamplePlugin] Plugin is unloading...');
+    console.log('[ExamplePlugin] Cleaned up successfully!');
+  },
+
+  // Exports for other plugins to use via ctx.require()
+  exports: null // Will be set during onLoad
+};

example-plugin/plugin-metadata.json

@@ -0,0 +1,9 @@
+{
+  "name": "Example Plugin",
+  "version": "2.0.0",
+  "description": "A comprehensive example plugin demonstrating all plugin API features including commands, interceptors, settings, and more",
+  "author": "Paarrot Team",
+  "homepage": "https://github.com/Paarrot/cinny-desktop",
+  "thumbnail": "https://raw.githubusercontent.com/Paarrot/cinny-desktop/main/icons/icon.png",
+  "tags": ["example", "demo", "utility", "commands", "interceptors"]
+}

paarrot-api.postman_collection.json

@@ -0,0 +1,274 @@
+{
+  "info": {
+    "_postman_id": "paarrot-api-collection",
+    "name": "Paarrot API",
+    "description": "API endpoints for controlling Paarrot (Cinny Desktop) features like muting, deafening, channel navigation, and messaging.",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+    "_exporter_id": "paarrot-api"
+  },
+  "item": [
+    {
+      "name": "Health & Status",
+      "item": [
+        {
+          "name": "Health Check",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/health",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "health"
+              ]
+            },
+            "description": "Check if the API server is running and healthy."
+          }
+        },
+        {
+          "name": "Get Status",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/status",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "status"
+              ]
+            },
+            "description": "Get current application status including mute/deafen state, current room, connection status, and user ID."
+          }
+        }
+      ]
+    },
+    {
+      "name": "Audio Controls",
+      "item": [
+        {
+          "name": "Toggle Mute",
+          "request": {
+            "method": "POST",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/mute/toggle",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "mute",
+                "toggle"
+              ]
+            },
+            "description": "Toggle microphone mute state. Works only when in an active call."
+          }
+        },
+        {
+          "name": "Set Mute",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n  \"muted\": true\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/mute",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "mute"
+              ]
+            },
+            "description": "Set microphone mute to a specific state (true/false). Works only when in an active call."
+          }
+        },
+        {
+          "name": "Toggle Deafen",
+          "request": {
+            "method": "POST",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/deafen/toggle",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "deafen",
+                "toggle"
+              ]
+            },
+            "description": "Toggle deafen state (mutes all incoming audio and your microphone). Works only when in an active call."
+          }
+        },
+        {
+          "name": "Set Deafen",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n  \"deafened\": true\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/deafen",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "deafen"
+              ]
+            },
+            "description": "Set deafen to a specific state (true/false). Works only when in an active call."
+          }
+        }
+      ]
+    },
+    {
+      "name": "Rooms & Channels",
+      "item": [
+        {
+          "name": "Get Channels",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/channels",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "channels"
+              ]
+            },
+            "description": "Get list of all available rooms/channels with their details (roomId, name, isDirect, avatar)."
+          }
+        },
+        {
+          "name": "Get Current Room",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/room/current",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "room",
+                "current"
+              ]
+            },
+            "description": "Get information about the currently active room."
+          }
+        },
+        {
+          "name": "Change Channel",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n  \"roomId\": \"!YourRoomId:server.com\"\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/channel",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "channel"
+              ]
+            },
+            "description": "Navigate to a different room/channel by providing its roomId."
+          }
+        }
+      ]
+    },
+    {
+      "name": "Messaging",
+      "item": [
+        {
+          "name": "Send Message to Room",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n  \"roomId\": \"!YourRoomId:server.com\",\n  \"message\": \"Hello from Postman!\"\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/message",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "message"
+              ]
+            },
+            "description": "Send a text message to a specific room by providing roomId and message content."
+          }
+        },
+        {
+          "name": "Send Message to Current Room",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n  \"message\": \"Hello from Postman!\"\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/message/current",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "message",
+                "current"
+              ]
+            },
+            "description": "Send a text message to the currently active room."
+          }
+        }
+      ]
+    }
+  ],
+  "variable": [
+    {
+      "key": "baseUrl",
+      "value": "http://127.0.0.1:33384",
+      "type": "string"
+    }
+  ]
+}

package.json

@@ -1,24 +1,51 @@
 {
-  "name": "cinny",
-  "version": "4.10.2",
-  "description": "Yet another matrix client",
-  "main": "index.js",
+  "name": "paarrot",
+  "version": "4.11.111",
+  "description": "Paarrot - A Matrix client based on Cinny",
+  "homepage": "https://github.com/Paarrot/Paarrot-Desktop",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Paarrot/Paarrot-Desktop.git"
+  },
+  "main": "electron/main.js",
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
-    "tauri": "powershell Copy-Item config.json cinny/; tauri",
-    "release": "node scripts/release.mjs"
+    "dev": "concurrently \"npm run dev:vite\" \"npm run dev:electron\"",
+    "dev:vite": "cd cinny && npm start",
+    "dev:electron": "wait-on http://localhost:38347 && cross-env NODE_ENV=development electron .",
+    "build": "node -e \"require('fs').copyFileSync('config.json', 'cinny/config.json')\" && cd cinny && npm run build && cd .. && electron-builder --publish always",
+    "build:local": "node -e \"require('fs').copyFileSync('config.json', 'cinny/config.json')\" && cd cinny && npm run build && cd .. && electron-builder",
+    "build:linux": "npm run build -- --linux",
+    "build:win": "npm run build -- --win",
+    "postman:generate": "node scripts/generate-postman-collection.js"
   },
   "keywords": [],
-  "author": "Ajay Bura",
+  "author": {
+    "name": "Mates.Media",
+    "email": "mates.media@users.noreply.github.com"
+  },
   "license": "AGPL-3.0-only",
   "dependencies": {
-    "@tauri-apps/api": "^2.0.0"
+    "adm-zip": "^0.5.16",
+    "body-parser": "2.2.2",
+    "cors": "2.8.6",
+    "electron-store": "^8.2.0",
+    "electron-updater": "^6.3.9",
+    "express": "5.2.1",
+    "open": "11.0.0"
   },
   "devDependencies": {
     "@actions/github": "6.0.0",
-    "@tauri-apps/cli": "^2.0.0",
-    "node-fetch": "3.3.2"
+    "@electron/rebuild": "4.0.3",
+    "concurrently": "9.2.1",
+    "cross-env": "10.1.0",
+    "electron": "40.6.0",
+    "electron-builder": "26.8.1",
+    "node-fetch": "3.3.2",
+    "png2icons": "2.0.1",
+    "sharp": "0.34.5",
+    "wait-on": "9.0.4"
   }
 }

scripts/generate-icons.mjs

@@ -0,0 +1,63 @@
+import sharp from 'sharp';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import png2icons from 'png2icons';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+const sourceIcon = path.join(rootDir, 'appicon-square.png');
+
+// Electron desktop icons
+const electronIcons = [
+  { name: '16x16.png', size: 16 },
+  { name: '24x24.png', size: 24 },
+  { name: '32x32.png', size: 32 },
+  { name: '48x48.png', size: 48 },
+  { name: '64x64.png', size: 64 },
+  { name: '128x128.png', size: 128 },
+  { name: '256x256.png', size: 256 },
+  { name: '512x512.png', size: 512 },
+  { name: '1024x1024.png', size: 1024 },
+  { name: 'icon.png', size: 512 },
+];
+
+async function generateElectronIcons() {
+  const iconsDir = path.join(rootDir, 'icons');
+  
+  // Ensure icons directory exists
+  await fs.mkdir(iconsDir, { recursive: true });
+  
+  for (const icon of electronIcons) {
+    const outputPath = path.join(iconsDir, icon.name);
+    await sharp(sourceIcon)
+      .resize(icon.size, icon.size)
+      .png()
+      .toFile(outputPath);
+    console.log(`Generated: ${icon.name}`);
+  }
+
+  // Generate ICO file (Windows)
+  const sourceBuffer = await fs.readFile(sourceIcon);
+  const icoBuffer = png2icons.createICO(sourceBuffer, png2icons.BEZIER, 0, true, true);
+  await fs.writeFile(path.join(iconsDir, 'icon.ico'), icoBuffer);
+  console.log('Generated: icon.ico');
+
+  // Generate ICNS file (macOS)
+  const icnsBuffer = png2icons.createICNS(sourceBuffer, png2icons.BEZIER, 0);
+  await fs.writeFile(path.join(iconsDir, 'icon.icns'), icnsBuffer);
+  console.log('Generated: icon.icns');
+}
+
+async function main() {
+  console.log('Generating icons from:', sourceIcon);
+  console.log('');
+  
+  console.log('=== Electron Desktop Icons ===');
+  await generateElectronIcons();
+  console.log('');
+  
+  console.log('Done!');
+}
+
+main().catch(console.error);

scripts/generate-postman-collection.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+/**
+ * Generate Postman collection from API documentation
+ * This script reads the API.md file and generates a Postman collection
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const collection = {
+  info: {
+    _postman_id: 'paarrot-api-collection',
+    name: 'Paarrot API',
+    description: 'API endpoints for controlling Paarrot (Cinny Desktop) features like muting, deafening, channel navigation, and messaging.',
+    schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json',
+    _exporter_id: 'paarrot-api',
+  },
+  item: [
+    {
+      name: 'Health & Status',
+      item: [
+        {
+          name: 'Health Check',
+          request: {
+            method: 'GET',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/health',
+              host: ['{{baseUrl}}'],
+              path: ['health'],
+            },
+            description: 'Check if the API server is running and healthy.',
+          },
+        },
+        {
+          name: 'Get Status',
+          request: {
+            method: 'GET',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/status',
+              host: ['{{baseUrl}}'],
+              path: ['status'],
+            },
+            description: 'Get current application status including mute/deafen state, current room, connection status, and user ID.',
+          },
+        },
+      ],
+    },
+    {
+      name: 'Audio Controls',
+      item: [
+        {
+          name: 'Toggle Mute',
+          request: {
+            method: 'POST',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/mute/toggle',
+              host: ['{{baseUrl}}'],
+              path: ['mute', 'toggle'],
+            },
+            description: 'Toggle microphone mute state. Works only when in an active call.',
+          },
+        },
+        {
+          name: 'Set Mute',
+          request: {
+            method: 'POST',
+            header: [{ key: 'Content-Type', value: 'application/json' }],
+            body: {
+              mode: 'raw',
+              raw: JSON.stringify({ muted: true }, null, 2),
+            },
+            url: {
+              raw: '{{baseUrl}}/mute',
+              host: ['{{baseUrl}}'],
+              path: ['mute'],
+            },
+            description: 'Set microphone mute to a specific state (true/false). Works only when in an active call.',
+          },
+        },
+        {
+          name: 'Toggle Deafen',
+          request: {
+            method: 'POST',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/deafen/toggle',
+              host: ['{{baseUrl}}'],
+              path: ['deafen', 'toggle'],
+            },
+            description: 'Toggle deafen state (mutes all incoming audio and your microphone). Works only when in an active call.',
+          },
+        },
+        {
+          name: 'Set Deafen',
+          request: {
+            method: 'POST',
+            header: [{ key: 'Content-Type', value: 'application/json' }],
+            body: {
+              mode: 'raw',
+              raw: JSON.stringify({ deafened: true }, null, 2),
+            },
+            url: {
+              raw: '{{baseUrl}}/deafen',
+              host: ['{{baseUrl}}'],
+              path: ['deafen'],
+            },
+            description: 'Set deafen to a specific state (true/false). Works only when in an active call.',
+          },
+        },
+      ],
+    },
+    {
+      name: 'Rooms & Channels',
+      item: [
+        {
+          name: 'Get Channels',
+          request: {
+            method: 'GET',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/channels',
+              host: ['{{baseUrl}}'],
+              path: ['channels'],
+            },
+            description: 'Get list of all available rooms/channels with their details (roomId, name, isDirect, avatar).',
+          },
+        },
+        {
+          name: 'Get Current Room',
+          request: {
+            method: 'GET',
+            header: [],
+            url: {
+              raw: '{{baseUrl}}/room/current',
+              host: ['{{baseUrl}}'],
+              path: ['room', 'current'],
+            },
+            description: 'Get information about the currently active room.',
+          },
+        },
+        {
+          name: 'Change Channel',
+          request: {
+            method: 'POST',
+            header: [{ key: 'Content-Type', value: 'application/json' }],
+            body: {
+              mode: 'raw',
+              raw: JSON.stringify({ roomId: '!YourRoomId:server.com' }, null, 2),
+            },
+            url: {
+              raw: '{{baseUrl}}/channel',
+              host: ['{{baseUrl}}'],
+              path: ['channel'],
+            },
+            description: 'Navigate to a different room/channel by providing its roomId.',
+          },
+        },
+      ],
+    },
+    {
+      name: 'Messaging',
+      item: [
+        {
+          name: 'Send Message to Room',
+          request: {
+            method: 'POST',
+            header: [{ key: 'Content-Type', value: 'application/json' }],
+            body: {
+              mode: 'raw',
+              raw: JSON.stringify(
+                {
+                  roomId: '!YourRoomId:server.com',
+                  message: 'Hello from Postman!',
+                },
+                null,
+                2
+              ),
+            },
+            url: {
+              raw: '{{baseUrl}}/message',
+              host: ['{{baseUrl}}'],
+              path: ['message'],
+            },
+            description: 'Send a text message to a specific room by providing roomId and message content.',
+          },
+        },
+        {
+          name: 'Send Message to Current Room',
+          request: {
+            method: 'POST',
+            header: [{ key: 'Content-Type', value: 'application/json' }],
+            body: {
+              mode: 'raw',
+              raw: JSON.stringify({ message: 'Hello from Postman!' }, null, 2),
+            },
+            url: {
+              raw: '{{baseUrl}}/message/current',
+              host: ['{{baseUrl}}'],
+              path: ['message', 'current'],
+            },
+            description: 'Send a text message to the currently active room.',
+          },
+        },
+      ],
+    },
+  ],
+  variable: [
+    {
+      key: 'baseUrl',
+      value: 'http://127.0.0.1:33384',
+      type: 'string',
+    },
+  ],
+};
+
+// Write the collection to file (in the project root)
+const outputPath = path.join(__dirname, '..', 'paarrot-api.postman_collection.json');
+fs.writeFileSync(outputPath, JSON.stringify(collection, null, 2) + '\n');
+
+console.log('✅ Postman collection generated:', outputPath);

scripts/release.mjs

@@ -1,108 +0,0 @@
-import fetch from "node-fetch";
-import { getOctokit, context } from "@actions/github";
-
-async function getAssetSign(url) {
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/octet-stream",
-    },
-  });
-
-  return response.text();
-}
-
-async function createTauriRelease() {
-  if (process.env.GITHUB_TOKEN === undefined) {
-    throw new Error("GITHUB_TOKEN is not found!");
-  }
-
-  const github = getOctokit(process.env.GITHUB_TOKEN);
-  const { repos } = github.rest;
-  const repoMetaData = {
-    owner: context.repo.owner,
-    repo: context.repo.repo,
-  };
-
-  const tagsResult = await repos.listTags({ ...repoMetaData, per_page: 10, page: 1 });
-  const latestTag = tagsResult.data.find((tag) => tag.name.startsWith("v"));
-  console.log(latestTag);
-
-  const latestRelease = await repos.getReleaseByTag({ ...repoMetaData, tag: latestTag.name });
-  const latestAssets = latestRelease.data.assets;
-
-  const windowsX86_64 = {};
-  const linuxX86_64 = {};
-  const darwinX86_64 = {};
-  const darwinAarch64 = {};
-
-  const promises = latestAssets.map(async (asset) => {
-    const { name, browser_download_url } = asset;
-
-    if (/\.msi\.zip$/.test(name)) {
-      windowsX86_64.url = browser_download_url;
-    }
-    if (/\.msi\.zip\.sig$/.test(name)) {
-      windowsX86_64.signature = await getAssetSign(browser_download_url);
-    }
-
-    if (/\.AppImage\.tar\.gz$/.test(name)) {
-      linuxX86_64.url = browser_download_url;
-    }
-    if (/\.AppImage\.tar\.gz\.sig$/.test(name)) {
-      linuxX86_64.signature = await getAssetSign(browser_download_url);
-    }
-
-    if (/universal\.app\.tar\.gz$/.test(name)) {
-      darwinX86_64.url = browser_download_url;
-    }
-    if (/universal\.app\.tar\.gz\.sig$/.test(name)) {
-      darwinX86_64.signature = await getAssetSign(browser_download_url);
-    }
-
-    if (/universal\.app\.tar\.gz$/.test(name)) {
-      darwinAarch64.url = browser_download_url;
-    }
-    if (/universal\.app\.tar\.gz\.sig$/.test(name)) {
-      darwinAarch64.signature = await getAssetSign(browser_download_url);
-    }
-  });
-
-  await Promise.allSettled(promises);
-
-  const releaseData = {
-    name: latestTag.name,
-    notes: `https://github.com/${repoMetaData.owner}/${repoMetaData.repo}/releases/tag/${latestTag.name}`,
-    pub_date: new Date().toISOString(),
-    platforms: {},
-  };
-
-  if (windowsX86_64.url) releaseData.platforms["windows-x86_64"] = windowsX86_64;
-  else console.error('Failed to get release for windowsX86_64');
-
-  if (linuxX86_64.url) releaseData.platforms["linux-x86_64"] = linuxX86_64;
-  else console.error('Failed to get release for linuxX86_64');
-
-  if (darwinX86_64.url) releaseData.platforms["darwin-x86_64"] = darwinX86_64;
-  else console.error('Failed to get release for darwinX86_64');
-
-  if (darwinAarch64.url) releaseData.platforms["darwin-aarch64"] = darwinAarch64;
-  else console.error('Failed to get release for darwinAarch64');
-
-  const releaseResult = await repos.getReleaseByTag({ ...repoMetaData, tag: 'tauri' });
-  const tauriRelease = releaseResult.data;
-
-  const prevReleaseAsset = tauriRelease.assets.find((asset) => asset.name === 'release.json');
-  if (prevReleaseAsset) {
-    await repos.deleteReleaseAsset({ ...repoMetaData, asset_id: prevReleaseAsset.id });
-  }
-
-  console.log(releaseData);
-  await repos.uploadReleaseAsset({
-    ...repoMetaData,
-    release_id: tauriRelease.id,
-    name: 'release.json',
-    data: JSON.stringify(releaseData, null, 2),
-  });
-}
-createTauriRelease();

src-tauri/.gitignore

@@ -1,6 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-/target/
-WixTools
-
-.tauri-private.key

src-tauri/.tauri-private.key.pub

@@ -1 +0,0 @@
-dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDExREU1NkVBMDY4MzcxMjAKUldRZ2NZTUc2bGJlRVNaQldnMXpJcHlocVpCWUNNaUdicjBGMVRsck1GQXhvTnJiOUNhVVRHSzQK

src-tauri/Cargo.toml

@@ -1,39 +0,0 @@
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[package]
-name = "cinny"
-version = "4.10.2"
-description = "Yet another matrix client"
-authors = ["Ajay Bura"]
-license = "AGPL-3.0-only"
-repository = "https://github.com/cinnyapp/cinny-desktop"
-default-run = "cinny"
-edition = "2021"
-rust-version = "1.70"
-
-[lib]
-name = "cinny_lib"
-crate-type = ["staticlib", "cdylib", "lib"]
-
-[build-dependencies]
-tauri-build = { version = "2", features = [] }
-
-[dependencies]
-serde_json = "1.0"
-serde = { version = "1.0", features = ["derive"] }
-tauri = { version = "2", features = ["devtools"] }
-tauri-plugin-localhost = "2"
-tauri-plugin-window-state = "2"
-tauri-plugin-shell = "2"
-tauri-plugin-notification = "2"
-
-[target."cfg(any(target_os = \"android\", target_os = \"ios\"))".dependencies]
-tauri-plugin-deep-link = "2"
-
-[target."cfg(not(any(target_os = \"android\", target_os = \"ios\")))".dependencies]
-tauri-plugin-single-instance = "2"
-tauri-plugin-updater = "2"
-
-[features]
-default = ["custom-protocol"]
-custom-protocol = ["tauri/custom-protocol"]

src-tauri/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-  tauri_build::build()
-}

src-tauri/capabilities/default.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Default capability for all windows",
+  "windows": ["*"],
+  "platforms": ["linux", "windows", "macOS"],
+  "permissions": [
+    "core:default",
+    "core:webview:allow-internal-toggle-devtools",
+    "opener:default",
+    "opener:allow-open-url",
+    "opener:allow-default-urls",
+    "notification:default",
+    "notification:allow-register-listener",
+    "autostart:default",
+    "updater:default",
+    "updater:allow-check",
+    "updater:allow-download",
+    "updater:allow-download-and-install",
+    "dialog:default",
+    "process:allow-restart",
+    {
+      "identifier": "http:default",
+      "allow": [
+        { "url": "https://api.telegram.org/**" }
+      ]
+    }
+  ]
+}

src-tauri/gen/android/.editorconfig

@@ -1,12 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = false
-insert_final_newline = false

src-tauri/gen/android/.gitignore

@@ -1,19 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-key.properties
-
-/.tauri
-/tauri.settings.gradle

src-tauri/gen/android/app/.gitignore

@@ -1,6 +0,0 @@
-/src/main/java/in/cinny/app/generated
-/src/main/jniLibs/**/*.so
-/src/main/assets/tauri.conf.json
-/tauri.build.gradle.kts
-/proguard-tauri.pro
-/tauri.properties

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

@@ -1,70 +0,0 @@
-import java.util.Properties
-
-plugins {
-    id("com.android.application")
-    id("org.jetbrains.kotlin.android")
-    id("rust")
-}
-
-val tauriProperties = Properties().apply {
-    val propFile = file("tauri.properties")
-    if (propFile.exists()) {
-        propFile.inputStream().use { load(it) }
-    }
-}
-
-android {
-    compileSdk = 36
-    namespace = "in.cinny.app"
-    defaultConfig {
-        manifestPlaceholders["usesCleartextTraffic"] = "false"
-        applicationId = "in.cinny.app"
-        minSdk = 24
-        targetSdk = 36
-        versionCode = tauriProperties.getProperty("tauri.android.versionCode", "1").toInt()
-        versionName = tauriProperties.getProperty("tauri.android.versionName", "1.0")
-    }
-    buildTypes {
-        getByName("debug") {
-            manifestPlaceholders["usesCleartextTraffic"] = "true"
-            isDebuggable = true
-            isJniDebuggable = true
-            isMinifyEnabled = false
-            packaging {                jniLibs.keepDebugSymbols.add("*/arm64-v8a/*.so")
-                jniLibs.keepDebugSymbols.add("*/armeabi-v7a/*.so")
-                jniLibs.keepDebugSymbols.add("*/x86/*.so")
-                jniLibs.keepDebugSymbols.add("*/x86_64/*.so")
-            }
-        }
-        getByName("release") {
-            isMinifyEnabled = true
-            proguardFiles(
-                *fileTree(".") { include("**/*.pro") }
-                    .plus(getDefaultProguardFile("proguard-android-optimize.txt"))
-                    .toList().toTypedArray()
-            )
-        }
-    }
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-    buildFeatures {
-        buildConfig = true
-    }
-}
-
-rust {
-    rootDirRel = "../../../"
-}
-
-dependencies {
-    implementation("androidx.webkit:webkit:1.14.0")
-    implementation("androidx.appcompat:appcompat:1.7.1")
-    implementation("androidx.activity:activity-ktx:1.10.1")
-    implementation("com.google.android.material:material:1.12.0")
-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.1.4")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.0")
-}
-
-apply(from = "tauri.build.gradle.kts")

src-tauri/gen/android/app/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

src-tauri/gen/android/app/src/main/AndroidManifest.xml

@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <uses-permission android:name="android.permission.VIBRATE" />
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
-    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
-
-    <!-- AndroidTV support -->
-    <uses-feature android:name="android.software.leanback" android:required="false" />
-
-    <application
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/Theme.cinny"
-        android:usesCleartextTraffic="${usesCleartextTraffic}">
-        <activity
-            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode"
-            android:launchMode="singleTask"
-            android:label="@string/main_activity_title"
-            android:name=".MainActivity"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-                <!-- AndroidTV support -->
-                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <!-- Background sync service -->
-        <service
-            android:name=".SyncService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="dataSync" />
-
-        <!-- Boot receiver to restart service -->
-        <receiver
-            android:name=".BootReceiver"
-            android:enabled="true"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-            </intent-filter>
-        </receiver>
-
-        <provider
-          android:name="androidx.core.content.FileProvider"
-          android:authorities="${applicationId}.fileprovider"
-          android:exported="false"
-          android:grantUriPermissions="true">
-          <meta-data
-            android:name="android.support.FILE_PROVIDER_PATHS"
-            android:resource="@xml/file_paths" />
-        </provider>
-    </application>
-</manifest>

src-tauri/gen/android/app/src/main/java/in/cinny/app/BootReceiver.kt

@@ -1,18 +0,0 @@
-package `in`.cinny.app
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-
-/**
- * Receives boot completed broadcast to restart the sync service
- * after device reboot.
- */
-class BootReceiver : BroadcastReceiver() {
-    override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
-            // Start the sync service after boot
-            SyncService.start(context)
-        }
-    }
-}

src-tauri/gen/android/app/src/main/java/in/cinny/app/MainActivity.kt

@@ -1,48 +0,0 @@
-package `in`.cinny.app
-
-import android.Manifest
-import android.content.pm.PackageManager
-import android.os.Build
-import android.os.Bundle
-import androidx.core.app.ActivityCompat
-import androidx.core.content.ContextCompat
-
-/**
- * Main activity for Cinny. Handles permission requests and
- * starts the background sync service for notifications.
- */
-class MainActivity : TauriActivity() {
-
-    companion object {
-        private const val NOTIFICATION_PERMISSION_CODE = 1001
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        requestNotificationPermission()
-        startSyncService()
-    }
-
-    override fun onResume() {
-        super.onResume()
-        // Ensure sync service is running when app is in foreground
-        startSyncService()
-    }
-
-    private fun requestNotificationPermission() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) 
-                != PackageManager.PERMISSION_GRANTED) {
-                ActivityCompat.requestPermissions(
-                    this,
-                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
-                    NOTIFICATION_PERMISSION_CODE
-                )
-            }
-        }
-    }
-
-    private fun startSyncService() {
-        SyncService.start(this)
-    }
-}

src-tauri/gen/android/app/src/main/java/in/cinny/app/SyncService.kt

@@ -1,114 +0,0 @@
-package `in`.cinny.app
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.os.IBinder
-import android.os.PowerManager
-import androidx.core.app.NotificationCompat
-
-/**
- * Foreground service to keep Matrix sync connection alive in background.
- * This service maintains a wake lock and shows a persistent notification
- * to prevent Android from killing the app while syncing.
- */
-class SyncService : Service() {
-
-    companion object {
-        private const val CHANNEL_ID = "cinny_sync_channel"
-        private const val NOTIFICATION_ID = 1001
-        private const val WAKE_LOCK_TAG = "Cinny:SyncWakeLock"
-
-        fun start(context: Context) {
-            val intent = Intent(context, SyncService::class.java)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
-            }
-        }
-
-        fun stop(context: Context) {
-            val intent = Intent(context, SyncService::class.java)
-            context.stopService(intent)
-        }
-    }
-
-    private var wakeLock: PowerManager.WakeLock? = null
-
-    override fun onBind(intent: Intent?): IBinder? = null
-
-    override fun onCreate() {
-        super.onCreate()
-        createNotificationChannel()
-        acquireWakeLock()
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        val notification = createNotification()
-        startForeground(NOTIFICATION_ID, notification)
-        return START_STICKY
-    }
-
-    override fun onDestroy() {
-        releaseWakeLock()
-        super.onDestroy()
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                "Matrix Sync",
-                NotificationManager.IMPORTANCE_LOW
-            ).apply {
-                description = "Keeps Cinny connected for message notifications"
-                setShowBadge(false)
-            }
-            val manager = getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
-        }
-    }
-
-    private fun createNotification(): Notification {
-        val intent = Intent(this, MainActivity::class.java)
-        val pendingIntent = PendingIntent.getActivity(
-            this, 0, intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("Cinny")
-            .setContentText("Connected to Matrix")
-            .setSmallIcon(R.mipmap.ic_launcher)
-            .setOngoing(true)
-            .setContentIntent(pendingIntent)
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .setCategory(NotificationCompat.CATEGORY_SERVICE)
-            .build()
-    }
-
-    private fun acquireWakeLock() {
-        val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
-        wakeLock = powerManager.newWakeLock(
-            PowerManager.PARTIAL_WAKE_LOCK,
-            WAKE_LOCK_TAG
-        ).apply {
-            acquire(10 * 60 * 1000L) // 10 minutes, will be renewed
-        }
-    }
-
-    private fun releaseWakeLock() {
-        wakeLock?.let {
-            if (it.isHeld) {
-                it.release()
-            }
-        }
-        wakeLock = null
-    }
-}

src-tauri/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>

src-tauri/gen/android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>

src-tauri/gen/android/app/src/main/res/layout/activity_main.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".MainActivity">
-
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Hello World!"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintLeft_toLeftOf="parent"
-        app:layout_constraintRight_toRightOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-
-</androidx.constraintlayout.widget.ConstraintLayout>

src-tauri/gen/android/app/src/main/res/values-night/themes.xml

@@ -1,6 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.cinny" parent="Theme.MaterialComponents.DayNight.NoActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-</resources>

src-tauri/gen/android/app/src/main/res/values/colors.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="purple_200">#FFBB86FC</color>
-    <color name="purple_500">#FF6200EE</color>
-    <color name="purple_700">#FF3700B3</color>
-    <color name="teal_200">#FF03DAC5</color>
-    <color name="teal_700">#FF018786</color>
-    <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
-</resources>

src-tauri/gen/android/app/src/main/res/values/strings.xml

@@ -1,4 +0,0 @@
-<resources>
-    <string name="app_name">Cinny</string>
-    <string name="main_activity_title">Cinny</string>
-</resources>

src-tauri/gen/android/app/src/main/res/values/themes.xml

@@ -1,6 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.cinny" parent="Theme.MaterialComponents.DayNight.NoActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-</resources>

src-tauri/gen/android/app/src/main/res/xml/file_paths.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<paths xmlns:android="http://schemas.android.com/apk/res/android">
-  <external-path name="my_images" path="." />
-  <cache-path name="my_cache_images" path="." />
-</paths>

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

@@ -1,22 +0,0 @@
-buildscript {
-    repositories {
-        google()
-        mavenCentral()
-    }
-    dependencies {
-        classpath("com.android.tools.build:gradle:8.11.0")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25")
-    }
-}
-
-allprojects {
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-
-tasks.register("clean").configure {
-    delete("build")
-}
-

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

@@ -1,23 +0,0 @@
-plugins {
-    `kotlin-dsl`
-}
-
-gradlePlugin {
-    plugins {
-        create("pluginsForCoolKids") {
-            id = "rust"
-            implementationClass = "RustPlugin"
-        }
-    }
-}
-
-repositories {
-    google()
-    mavenCentral()
-}
-
-dependencies {
-    compileOnly(gradleApi())
-    implementation("com.android.tools.build:gradle:8.11.0")
-}
-

src-tauri/gen/android/buildSrc/src/main/java/in/cinny/app/kotlin/BuildTask.kt

@@ -1,68 +0,0 @@
-import java.io.File
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.gradle.api.DefaultTask
-import org.gradle.api.GradleException
-import org.gradle.api.logging.LogLevel
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
-
-open class BuildTask : DefaultTask() {
-    @Input
-    var rootDirRel: String? = null
-    @Input
-    var target: String? = null
-    @Input
-    var release: Boolean? = null
-
-    @TaskAction
-    fun assemble() {
-        val executable = """npm""";
-        try {
-            runTauriCli(executable)
-        } catch (e: Exception) {
-            if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-                // Try different Windows-specific extensions
-                val fallbacks = listOf(
-                    "$executable.exe",
-                    "$executable.cmd",
-                    "$executable.bat",
-                )
-                
-                var lastException: Exception = e
-                for (fallback in fallbacks) {
-                    try {
-                        runTauriCli(fallback)
-                        return
-                    } catch (fallbackException: Exception) {
-                        lastException = fallbackException
-                    }
-                }
-                throw lastException
-            } else {
-                throw e;
-            }
-        }
-    }
-
-    fun runTauriCli(executable: String) {
-        val rootDirRel = rootDirRel ?: throw GradleException("rootDirRel cannot be null")
-        val target = target ?: throw GradleException("target cannot be null")
-        val release = release ?: throw GradleException("release cannot be null")
-        val args = listOf("run", "--", "tauri", "android", "android-studio-script");
-
-        project.exec {
-            workingDir(File(project.projectDir, rootDirRel))
-            executable(executable)
-            args(args)
-            if (project.logger.isEnabled(LogLevel.DEBUG)) {
-                args("-vv")
-            } else if (project.logger.isEnabled(LogLevel.INFO)) {
-                args("-v")
-            }
-            if (release) {
-                args("--release")
-            }
-            args(listOf("--target", target))
-        }.assertNormalExitValue()
-    }
-}

src-tauri/gen/android/buildSrc/src/main/java/in/cinny/app/kotlin/RustPlugin.kt

@@ -1,85 +0,0 @@
-import com.android.build.api.dsl.ApplicationExtension
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.get
-
-const val TASK_GROUP = "rust"
-
-open class Config {
-    lateinit var rootDirRel: String
-}
-
-open class RustPlugin : Plugin<Project> {
-    private lateinit var config: Config
-
-    override fun apply(project: Project) = with(project) {
-        config = extensions.create("rust", Config::class.java)
-
-        val defaultAbiList = listOf("arm64-v8a", "armeabi-v7a", "x86", "x86_64");
-        val abiList = (findProperty("abiList") as? String)?.split(',') ?: defaultAbiList
-
-        val defaultArchList = listOf("arm64", "arm", "x86", "x86_64");
-        val archList = (findProperty("archList") as? String)?.split(',') ?: defaultArchList
-
-        val targetsList = (findProperty("targetList") as? String)?.split(',') ?: listOf("aarch64", "armv7", "i686", "x86_64")
-
-        extensions.configure<ApplicationExtension> {
-            @Suppress("UnstableApiUsage")
-            flavorDimensions.add("abi")
-            productFlavors {
-                create("universal") {
-                    dimension = "abi"
-                    ndk {
-                        abiFilters += abiList
-                    }
-                }
-                defaultArchList.forEachIndexed { index, arch ->
-                    create(arch) {
-                        dimension = "abi"
-                        ndk {
-                            abiFilters.add(defaultAbiList[index])
-                        }
-                    }
-                }
-            }
-        }
-
-        afterEvaluate {
-            for (profile in listOf("debug", "release")) {
-                val profileCapitalized = profile.replaceFirstChar { it.uppercase() }
-                val buildTask = tasks.maybeCreate(
-                    "rustBuildUniversal$profileCapitalized",
-                    DefaultTask::class.java
-                ).apply {
-                    group = TASK_GROUP
-                    description = "Build dynamic library in $profile mode for all targets"
-                }
-
-                tasks["mergeUniversal${profileCapitalized}JniLibFolders"].dependsOn(buildTask)
-
-                for (targetPair in targetsList.withIndex()) {
-                    val targetName = targetPair.value
-                    val targetArch = archList[targetPair.index]
-                    val targetArchCapitalized = targetArch.replaceFirstChar { it.uppercase() }
-                    val targetBuildTask = project.tasks.maybeCreate(
-                        "rustBuild$targetArchCapitalized$profileCapitalized",
-                        BuildTask::class.java
-                    ).apply {
-                        group = TASK_GROUP
-                        description = "Build dynamic library in $profile mode for $targetArch"
-                        rootDirRel = config.rootDirRel
-                        target = targetName
-                        release = profile == "release"
-                    }
-
-                    buildTask.dependsOn(targetBuildTask)
-                    tasks["merge$targetArchCapitalized${profileCapitalized}JniLibFolders"].dependsOn(
-                        targetBuildTask
-                    )
-                }
-            }
-        }
-    }
-}

src-tauri/gen/android/gradle.properties

@@ -1,24 +0,0 @@
-# Project-wide Gradle settings.
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app"s APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
-android.useAndroidX=true
-# Kotlin code style for this project: "official" or "obsolete":
-kotlin.code.style=official
-# Enables namespacing of each library's R class so that its R class includes only the
-# resources declared in the library itself and none from the library's dependencies,
-# thereby reducing the size of the R class for that library
-android.nonTransitiveRClass=true
-android.nonFinalResIds=false

src-tauri/gen/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-#Tue May 10 19:22:52 CST 2022
-distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
-distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME

src-tauri/gen/android/gradlew

@@ -1,185 +0,0 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"

src-tauri/gen/android/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

src-tauri/gen/android/settings.gradle

@@ -1,3 +0,0 @@
-include ':app'
-
-apply from: 'tauri.settings.gradle'

src-tauri/gen/schemas/capabilities.json

@@ -1 +0,0 @@
-{}