Use uv for Python management in CI and build script

- CI: install uv via astral-sh/setup-uv, use uv to install Python and run the build script (replaces setup-python which fails on self-hosted macOS runners) - build_sidecar.py: auto-detects uv and uses it for venv creation and package installation (much faster), falls back to standard venv + pip when uv is not available Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Skip setup-python on macOS, use system Python instead
2026-03-20 22:56:13 -07:00 · 2026-03-20 22:47:05 -07:00
13 changed files with 258 additions and 724 deletions
--- a/.gitea/workflows/build.yml
+++ b/.gitea/workflows/build.yml
@@ -0,0 +1,191 @@
+name: Build & Release
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+
+env:
+  PYTHON_VERSION: "3.11"
+  NODE_VERSION: "20"
+
+jobs:
+  build-sidecar:
+    name: Build sidecar (${{ matrix.target }})
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            platform: linux
+          - runner: windows-latest
+            target: x86_64-pc-windows-msvc
+            platform: windows
+          - runner: macos-latest
+            target: aarch64-apple-darwin
+            platform: macos
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python
+        run: uv python install ${{ env.PYTHON_VERSION }}
+
+      - name: Build sidecar
+        working-directory: python
+        run: uv run --python ${{ env.PYTHON_VERSION }} python build_sidecar.py --cpu-only
+
+      - name: Upload sidecar artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: sidecar-${{ matrix.target }}
+          path: python/dist/voice-to-notes-sidecar/
+          retention-days: 7
+
+  build-tauri:
+    name: Build app (${{ matrix.target }})
+    needs: build-sidecar
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            platform: linux
+          - runner: windows-latest
+            target: x86_64-pc-windows-msvc
+            platform: windows
+          - runner: macos-latest
+            target: aarch64-apple-darwin
+            platform: macos
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install system dependencies (Linux)
+        if: matrix.platform == 'linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
+
+      - name: Install system dependencies (macOS)
+        if: matrix.platform == 'macos'
+        run: |
+          brew install --quiet create-dmg || true
+
+      - name: Download sidecar artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: sidecar-${{ matrix.target }}
+          path: src-tauri/binaries/
+
+      - name: Make sidecar executable (Unix)
+        if: matrix.platform != 'windows'
+        run: chmod +x src-tauri/binaries/voice-to-notes-sidecar-${{ matrix.target }}
+
+      - name: Install npm dependencies
+        run: npm ci
+
+      - name: Build Tauri app
+        run: npm run tauri build
+        env:
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_CONFIG: '{"bundle":{"externalBin":["binaries/voice-to-notes-sidecar"]}}'
+
+      - name: Upload app artifacts (Linux)
+        if: matrix.platform == 'linux'
+        uses: actions/upload-artifact@v3
+        with:
+          name: app-${{ matrix.target }}
+          path: |
+            src-tauri/target/release/bundle/deb/*.deb
+            src-tauri/target/release/bundle/appimage/*.AppImage
+          retention-days: 30
+
+      - name: Upload app artifacts (Windows)
+        if: matrix.platform == 'windows'
+        uses: actions/upload-artifact@v3
+        with:
+          name: app-${{ matrix.target }}
+          path: |
+            src-tauri/target/release/bundle/msi/*.msi
+            src-tauri/target/release/bundle/nsis/*.exe
+          retention-days: 30
+
+      - name: Upload app artifacts (macOS)
+        if: matrix.platform == 'macos'
+        uses: actions/upload-artifact@v3
+        with:
+          name: app-${{ matrix.target }}
+          path: |
+            src-tauri/target/release/bundle/dmg/*.dmg
+            src-tauri/target/release/bundle/macos/*.app
+          retention-days: 30
+
+  release:
+    name: Create Release
+    needs: build-tauri
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install required tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y jq curl
+
+      - name: Download all app artifacts
+        uses: actions/download-artifact@v3
+        with:
+          path: artifacts/
+
+      - name: Generate release tag
+        id: tag
+        run: echo "tag=build-$(date +%Y%m%d-%H%M%S)" >> $GITHUB_OUTPUT
+
+      - name: Create release
+        env:
+          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
+          TAG: ${{ steps.tag.outputs.tag }}
+        run: |
+          # Create the release
+          RELEASE_ID=$(curl -s -X POST \
+            -H "Authorization: token ${BUILD_TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d "{\"tag_name\": \"${TAG}\", \"name\": \"Voice to Notes ${TAG}\", \"body\": \"Automated build from main branch.\", \"draft\": false, \"prerelease\": true}" \
+            "${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}/releases" | jq -r '.id')
+
+          echo "Release ID: ${RELEASE_ID}"
+
+          if [ "${RELEASE_ID}" = "null" ] || [ -z "${RELEASE_ID}" ]; then
+            echo "ERROR: Failed to create release. Check BUILD_TOKEN permissions."
+            exit 1
+          fi
+
+          # Upload all artifacts
+          find artifacts/ -type f \( -name "*.deb" -o -name "*.AppImage" -o -name "*.msi" -o -name "*.exe" -o -name "*.dmg" \) | while read file; do
+            filename=$(basename "$file")
+            echo "Uploading ${filename}..."
+            curl -s -X POST \
+              -H "Authorization: token ${BUILD_TOKEN}" \
+              -H "Content-Type: application/octet-stream" \
+              --data-binary "@${file}" \
+              "${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=${filename}"
+          done
--- a/.gitea/workflows/release.yml
+++ b/.gitea/workflows/release.yml
@@ -1,395 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches: [main]
-
-jobs:
-  bump-version:
-    name: Bump version and tag
-    # Skip if this is a version-bump commit (avoid infinite loop)
-    if: "!contains(github.event.head_commit.message, '[skip ci]')"
-    runs-on: ubuntu-latest
-    outputs:
-      new_version: ${{ steps.bump.outputs.new_version }}
-      tag: ${{ steps.bump.outputs.tag }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Configure git
-        run: |
-          git config user.name "Gitea Actions"
-          git config user.email "actions@gitea.local"
-
-      - name: Bump patch version
-        id: bump
-        run: |
-          # Read current version from package.json
-          CURRENT=$(grep '"version"' package.json | head -1 | sed 's/.*"version": *"\([^"]*\)".*/\1/')
-          echo "Current version: ${CURRENT}"
-
-          # Increment patch number
-          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
-
-          # Update src-tauri/tauri.conf.json
-          sed -i "s/\"version\": \"${CURRENT}\"/\"version\": \"${NEW_VERSION}\"/" src-tauri/tauri.conf.json
-
-          # Update src-tauri/Cargo.toml (match version = "x.y.z" in [package] section)
-          sed -i "s/^version = \"${CURRENT}\"/version = \"${NEW_VERSION}\"/" src-tauri/Cargo.toml
-
-          # Update python/pyproject.toml
-          sed -i "s/^version = \".*\"/version = \"${NEW_VERSION}\"/" python/pyproject.toml
-
-          echo "new_version=${NEW_VERSION}" >> $GITHUB_OUTPUT
-          echo "tag=v${NEW_VERSION}" >> $GITHUB_OUTPUT
-
-      - name: Commit and tag
-        env:
-          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
-        run: |
-          NEW_VERSION="${{ steps.bump.outputs.new_version }}"
-          git add package.json src-tauri/tauri.conf.json src-tauri/Cargo.toml python/pyproject.toml
-          git commit -m "chore: bump version to ${NEW_VERSION} [skip ci]"
-          git tag "v${NEW_VERSION}"
-
-          # Push using token for authentication
-          REMOTE_URL=$(git remote get-url origin | sed "s|://|://gitea-actions:${BUILD_TOKEN}@|")
-          git push "${REMOTE_URL}" HEAD:main
-          git push "${REMOTE_URL}" "v${NEW_VERSION}"
-
-      - name: Create Gitea release
-        env:
-          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
-        run: |
-          REPO_API="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
-          TAG="${{ steps.bump.outputs.tag }}"
-          RELEASE_NAME="Voice to Notes ${TAG}"
-
-          curl -s -X POST \
-            -H "Authorization: token ${BUILD_TOKEN}" \
-            -H "Content-Type: application/json" \
-            -d "{\"tag_name\": \"${TAG}\", \"name\": \"${RELEASE_NAME}\", \"body\": \"Automated build.\", \"draft\": false, \"prerelease\": false}" \
-            "${REPO_API}/releases"
-          echo "Created release: ${RELEASE_NAME}"
-
-  # ── Platform builds (run after version bump) ──
-
-  build-linux:
-    name: Build (Linux)
-    needs: bump-version
-    runs-on: ubuntu-latest
-    env:
-      PYTHON_VERSION: "3.11"
-      NODE_VERSION: "20"
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ needs.bump-version.outputs.tag }}
-
-      # ── Python sidecar ──
-      - name: Install uv
-        run: |
-          if command -v uv &> /dev/null; then
-            echo "uv already installed: $(uv --version)"
-          else
-            curl -LsSf https://astral.sh/uv/install.sh | sh
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install ffmpeg
-        run: sudo apt-get update && sudo apt-get install -y ffmpeg
-
-      - name: Set up Python
-        run: uv python install ${{ env.PYTHON_VERSION }}
-
-      - name: Build sidecar
-        working-directory: python
-        run: uv run --python ${{ env.PYTHON_VERSION }} python build_sidecar.py --cpu-only
-
-      - name: Package sidecar for Tauri
-        run: |
-          cd python/dist/voice-to-notes-sidecar && zip -r ../../../src-tauri/sidecar.zip .
-
-      # ── Tauri app ──
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-
-      - name: Install Rust stable
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable
-          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf xdg-utils
-
-      - name: Install npm dependencies
-        run: npm ci
-
-      - name: Build Tauri app
-        run: npm run tauri build
-
-      # ── Release ──
-      - name: Upload to release
-        env:
-          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
-        run: |
-          sudo apt-get install -y jq
-          REPO_API="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
-
-          TAG="${{ needs.bump-version.outputs.tag }}"
-          RELEASE_NAME="Voice to Notes ${TAG}"
-          echo "Release tag: ${TAG}"
-
-          RELEASE_ID=$(curl -s -H "Authorization: token ${BUILD_TOKEN}" \
-            "${REPO_API}/releases/tags/${TAG}" | jq -r '.id // empty')
-
-          if [ -z "${RELEASE_ID}" ] || [ "${RELEASE_ID}" = "null" ]; then
-            echo "ERROR: Failed to find release for tag ${TAG}."
-            exit 1
-          fi
-
-          echo "Release ID: ${RELEASE_ID}"
-
-          find src-tauri/target/release/bundle -type f -name "*.deb" | while IFS= read -r file; do
-            filename=$(basename "$file")
-            encoded_name=$(echo "$filename" | sed 's/ /%20/g')
-            echo "Uploading ${filename} ($(du -h "$file" | cut -f1))..."
-
-            ASSET_ID=$(curl -s -H "Authorization: token ${BUILD_TOKEN}" \
-              "${REPO_API}/releases/${RELEASE_ID}/assets" | jq -r ".[] | select(.name == \"${filename}\") | .id // empty")
-            if [ -n "${ASSET_ID}" ]; then
-              curl -s -X DELETE -H "Authorization: token ${BUILD_TOKEN}" \
-                "${REPO_API}/releases/${RELEASE_ID}/assets/${ASSET_ID}"
-            fi
-
-            HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
-              -H "Authorization: token ${BUILD_TOKEN}" \
-              -H "Content-Type: application/octet-stream" \
-              -T "$file" \
-              "${REPO_API}/releases/${RELEASE_ID}/assets?name=${encoded_name}")
-            echo "Upload response: HTTP ${HTTP_CODE}"
-          done
-
-  build-windows:
-    name: Build (Windows)
-    needs: bump-version
-    runs-on: windows-latest
-    env:
-      PYTHON_VERSION: "3.11"
-      NODE_VERSION: "20"
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ needs.bump-version.outputs.tag }}
-
-      # ── Python sidecar ──
-      - name: Install uv
-        shell: powershell
-        run: |
-          if (Get-Command uv -ErrorAction SilentlyContinue) {
-            Write-Host "uv already installed: $(uv --version)"
-          } else {
-            irm https://astral.sh/uv/install.ps1 | iex
-            echo "$env:USERPROFILE\.local\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          }
-
-      - name: Install ffmpeg
-        shell: powershell
-        run: choco install ffmpeg -y
-
-      - name: Set up Python
-        shell: powershell
-        run: uv python install ${{ env.PYTHON_VERSION }}
-
-      - name: Build sidecar
-        shell: powershell
-        working-directory: python
-        run: uv run --python ${{ env.PYTHON_VERSION }} python build_sidecar.py --cpu-only
-
-      - name: Package sidecar for Tauri
-        shell: powershell
-        run: |
-          Compress-Archive -Path python\dist\voice-to-notes-sidecar\* -DestinationPath src-tauri\sidecar.zip
-
-      # ── Tauri app ──
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-
-      - name: Install Rust stable
-        shell: powershell
-        run: |
-          if (Get-Command rustup -ErrorAction SilentlyContinue) {
-            rustup default stable
-          } else {
-            Invoke-WebRequest -Uri https://win.rustup.rs/x86_64 -OutFile rustup-init.exe
-            .\rustup-init.exe -y --default-toolchain stable
-            echo "$env:USERPROFILE\.cargo\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          }
-
-      - name: Install npm dependencies
-        shell: powershell
-        run: npm ci
-
-      - name: Build Tauri app
-        shell: powershell
-        run: npm run tauri build
-
-      # ── Release ──
-      - name: Upload to release
-        shell: powershell
-        env:
-          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
-        run: |
-          $REPO_API = "${{ github.server_url }}/api/v1/repos/${{ github.repository }}"
-          $Headers = @{ "Authorization" = "token $env:BUILD_TOKEN" }
-
-          $TAG = "${{ needs.bump-version.outputs.tag }}"
-          $RELEASE_NAME = "Voice to Notes ${TAG}"
-          Write-Host "Release tag: ${TAG}"
-
-          $release = Invoke-RestMethod -Uri "${REPO_API}/releases/tags/${TAG}" -Headers $Headers -ErrorAction Stop
-          $RELEASE_ID = $release.id
-          Write-Host "Release ID: ${RELEASE_ID}"
-
-          Get-ChildItem -Path src-tauri\target\release\bundle -Recurse -Include *.msi,*-setup.exe | ForEach-Object {
-            $filename = $_.Name
-            $encodedName = [System.Uri]::EscapeDataString($filename)
-            $size = [math]::Round($_.Length / 1MB, 1)
-            Write-Host "Uploading ${filename} (${size} MB)..."
-
-            try {
-              $assets = Invoke-RestMethod -Uri "${REPO_API}/releases/${RELEASE_ID}/assets" -Headers $Headers
-              $existing = $assets | Where-Object { $_.name -eq $filename }
-              if ($existing) {
-                Invoke-RestMethod -Uri "${REPO_API}/releases/${RELEASE_ID}/assets/$($existing.id)" -Method Delete -Headers $Headers
-              }
-            } catch {}
-
-            # Use curl for streaming upload (Invoke-RestMethod fails on large files)
-            $uploadUrl = "${REPO_API}/releases/${RELEASE_ID}/assets?name=${encodedName}"
-            $result = curl.exe --fail --silent --show-error `
-              -X POST `
-              -H "Authorization: token $env:BUILD_TOKEN" `
-              -H "Content-Type: application/octet-stream" `
-              --data-binary "@$($_.FullName)" `
-              "$uploadUrl" 2>&1
-            if ($LASTEXITCODE -eq 0) {
-              Write-Host "Upload successful: ${filename}"
-            } else {
-              Write-Host "WARNING: Upload failed for ${filename}: ${result}"
-            }
-          }
-
-  build-macos:
-    name: Build (macOS)
-    needs: bump-version
-    runs-on: macos-latest
-    env:
-      PYTHON_VERSION: "3.11"
-      NODE_VERSION: "20"
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ needs.bump-version.outputs.tag }}
-
-      # ── Python sidecar ──
-      - name: Install uv
-        run: |
-          if command -v uv &> /dev/null; then
-            echo "uv already installed: $(uv --version)"
-          else
-            curl -LsSf https://astral.sh/uv/install.sh | sh
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-          fi
-
-      - name: Install ffmpeg
-        run: brew install ffmpeg
-
-      - name: Set up Python
-        run: uv python install ${{ env.PYTHON_VERSION }}
-
-      - name: Build sidecar
-        working-directory: python
-        run: uv run --python ${{ env.PYTHON_VERSION }} python build_sidecar.py --cpu-only
-
-      - name: Package sidecar for Tauri
-        run: |
-          cd python/dist/voice-to-notes-sidecar && zip -r ../../../src-tauri/sidecar.zip .
-
-      # ── Tauri app ──
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-
-      - name: Install Rust stable
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable
-          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-
-      - name: Install system dependencies
-        run: brew install --quiet create-dmg || true
-
-      - name: Install npm dependencies
-        run: npm ci
-
-      - name: Build Tauri app
-        run: npm run tauri build
-
-      # ── Release ──
-      - name: Upload to release
-        env:
-          BUILD_TOKEN: ${{ secrets.BUILD_TOKEN }}
-        run: |
-          which jq || brew install jq
-
-          REPO_API="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
-
-          TAG="${{ needs.bump-version.outputs.tag }}"
-          RELEASE_NAME="Voice to Notes ${TAG}"
-          echo "Release tag: ${TAG}"
-
-          RELEASE_ID=$(curl -s -H "Authorization: token ${BUILD_TOKEN}" \
-            "${REPO_API}/releases/tags/${TAG}" | jq -r '.id // empty')
-
-          if [ -z "${RELEASE_ID}" ] || [ "${RELEASE_ID}" = "null" ]; then
-            echo "ERROR: Failed to find release for tag ${TAG}."
-            exit 1
-          fi
-
-          echo "Release ID: ${RELEASE_ID}"
-
-          find src-tauri/target/release/bundle -type f -name "*.dmg" | while IFS= read -r file; do
-            filename=$(basename "$file")
-            encoded_name=$(echo "$filename" | sed 's/ /%20/g')
-            echo "Uploading ${filename} ($(du -h "$file" | cut -f1))..."
-
-            ASSET_ID=$(curl -s -H "Authorization: token ${BUILD_TOKEN}" \
-              "${REPO_API}/releases/${RELEASE_ID}/assets" | jq -r ".[] | select(.name == \"${filename}\") | .id // empty")
-            if [ -n "${ASSET_ID}" ]; then
-              curl -s -X DELETE -H "Authorization: token ${BUILD_TOKEN}" \
-                "${REPO_API}/releases/${RELEASE_ID}/assets/${ASSET_ID}"
-            fi
-
-            HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
-              -H "Authorization: token ${BUILD_TOKEN}" \
-              -H "Content-Type: application/octet-stream" \
-              -T "$file" \
-              "${REPO_API}/releases/${RELEASE_ID}/assets?name=${encoded_name}")
-            echo "Upload response: HTTP ${HTTP_CODE}"
-          done
--- a/.gitignore
+++ b/.gitignore
@@ -50,6 +50,5 @@ Thumbs.db
 # Sidecar build artifacts
 src-tauri/binaries/*
 !src-tauri/binaries/.gitkeep
-src-tauri/sidecar.zip
 python/dist/
 python/build/
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "voice-to-notes",
-  "version": "0.2.5",
+  "version": "0.1.0",
  "description": "Desktop app for transcribing audio/video with speaker identification",
  "type": "module",
  "scripts": {
--- a/python/build_sidecar.py
+++ b/python/build_sidecar.py
@@ -92,39 +92,34 @@ def create_venv_and_install(cpu_only: bool) -> Path:

    # Determine python path inside venv
    if sys.platform == "win32":
-        python = str(venv_dir / "Scripts" / "python.exe")
+        python = str(venv_dir / "Scripts" / "python")
    else:
        python = str(venv_dir / "bin" / "python")

-    def pip_install(*args: str) -> None:
-        """Install packages. Pass package names and flags only, not 'install'."""
+    def pkg_install(*args: str) -> None:
        if use_uv:
-            # Use --python with the venv directory (not the python binary) for uv
-            subprocess.run(
-                ["uv", "pip", "install", "--python", str(venv_dir), *args],
-                check=True,
-            )
+            subprocess.run(["uv", "pip", "install", "--python", python, *args], check=True)
        else:
-            subprocess.run([python, "-m", "pip", "install", *args], check=True)
+            subprocess.run([python, "-m", "pip", *args], check=True)

    if not use_uv:
        # Upgrade pip (uv doesn't need this)
-        pip_install("--upgrade", "pip", "setuptools", "wheel")
+        pkg_install("install", "--upgrade", "pip", "setuptools", "wheel")

    # Install torch (CPU-only to avoid bundling ~2GB of CUDA libs)
    if cpu_only:
        print("[build] Installing PyTorch (CPU-only)")
-        pip_install(
-            "torch", "torchaudio",
+        pkg_install(
+            "install", "torch", "torchaudio",
            "--index-url", "https://download.pytorch.org/whl/cpu",
        )
    else:
        print("[build] Installing PyTorch (default, may include CUDA)")
-        pip_install("torch", "torchaudio")
+        pkg_install("install", "torch", "torchaudio")

    # Install project and dev deps (includes pyinstaller)
    print("[build] Installing project dependencies")
-    pip_install("-e", f"{SCRIPT_DIR}[dev]")
+    pkg_install("install", "-e", f"{SCRIPT_DIR}[dev]")

    return Path(python)

@@ -236,9 +231,10 @@ def main() -> None:
    python = create_venv_and_install(cpu_only)
    output_dir = run_pyinstaller(python)
    download_ffmpeg(output_dir)
+    rename_binary(output_dir, target_triple)

    print(f"\n[build] Done! Sidecar built at: {output_dir}")
-    print(f"[build] Copy directory to src-tauri/sidecar/ for Tauri resource bundling")
+    print(f"[build] Copy contents to src-tauri/binaries/ for Tauri bundling")


 if __name__ == "__main__":
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "voice-to-notes"
-version = "0.2.5"
+version = "0.1.0"
 description = "Python sidecar for Voice to Notes — transcription, diarization, and AI services"
 requires-python = ">=3.11"
 license = "MIT"
--- a/python/voice_to_notes.spec
+++ b/python/voice_to_notes.spec
@@ -33,13 +33,7 @@ a = Analysis(
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
-    excludes=[
-        "tkinter", "test", "unittest", "pip", "setuptools",
-        # ctranslate2.converters imports torch at module level and causes
-        # circular import crashes under PyInstaller. These modules are only
-        # needed for model format conversion, never for inference.
-        "ctranslate2.converters",
-    ],
+    excludes=["tkinter", "test", "unittest", "pip", "setuptools"],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher,
--- a/python/voice_to_notes/ipc/handlers.py
+++ b/python/voice_to_notes/ipc/handlers.py
@@ -41,15 +41,11 @@ def ping_handler(msg: IPCMessage) -> IPCMessage:

 def make_transcribe_handler() -> HandlerFunc:
    """Create a transcription handler with a persistent TranscribeService."""
-    service = None
+    from voice_to_notes.services.transcribe import TranscribeService, result_to_payload
+
+    service = TranscribeService()

    def handler(msg: IPCMessage) -> IPCMessage:
-        nonlocal service
-        if service is None:
-            from voice_to_notes.services.transcribe import TranscribeService
-            service = TranscribeService()
-        from voice_to_notes.services.transcribe import result_to_payload
-
        payload = msg.payload
        result = service.transcribe(
            request_id=msg.id,
@@ -70,15 +66,11 @@ def make_transcribe_handler() -> HandlerFunc:

 def make_diarize_handler() -> HandlerFunc:
    """Create a diarization handler with a persistent DiarizeService."""
-    service = None
+    from voice_to_notes.services.diarize import DiarizeService, diarization_to_payload
+
+    service = DiarizeService()

    def handler(msg: IPCMessage) -> IPCMessage:
-        nonlocal service
-        if service is None:
-            from voice_to_notes.services.diarize import DiarizeService
-            service = DiarizeService()
-        from voice_to_notes.services.diarize import diarization_to_payload
-
        payload = msg.payload
        result = service.diarize(
            request_id=msg.id,
@@ -171,15 +163,11 @@ def make_diarize_download_handler() -> HandlerFunc:

 def make_pipeline_handler() -> HandlerFunc:
    """Create a full pipeline handler (transcribe + diarize + merge)."""
-    service = None
+    from voice_to_notes.services.pipeline import PipelineService, pipeline_result_to_payload
+
+    service = PipelineService()

    def handler(msg: IPCMessage) -> IPCMessage:
-        nonlocal service
-        if service is None:
-            from voice_to_notes.services.pipeline import PipelineService
-            service = PipelineService()
-        from voice_to_notes.services.pipeline import pipeline_result_to_payload
-
        payload = msg.payload
        result = service.run(
            request_id=msg.id,
@@ -205,15 +193,11 @@ def make_pipeline_handler() -> HandlerFunc:

 def make_export_handler() -> HandlerFunc:
    """Create an export handler."""
-    service = None
+    from voice_to_notes.services.export import ExportService, make_export_request
+
+    service = ExportService()

    def handler(msg: IPCMessage) -> IPCMessage:
-        nonlocal service
-        if service is None:
-            from voice_to_notes.services.export import ExportService
-            service = ExportService()
-        from voice_to_notes.services.export import make_export_request
-
        request = make_export_request(msg.payload)
        output_path = service.export(request)
        return IPCMessage(
@@ -227,14 +211,11 @@ def make_export_handler() -> HandlerFunc:

 def make_ai_chat_handler() -> HandlerFunc:
    """Create an AI chat handler with persistent AIProviderService."""
-    service = None
-
-    def handler(msg: IPCMessage) -> IPCMessage:
-        nonlocal service
-        if service is None:
    from voice_to_notes.services.ai_provider import create_default_service
+
    service = create_default_service()

+    def handler(msg: IPCMessage) -> IPCMessage:
        payload = msg.payload
        action = payload.get("action", "chat")

--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "voice-to-notes"
-version = "0.2.5"
+version = "0.1.0"
 description = "Voice to Notes — desktop transcription with speaker identification"
 authors = ["Voice to Notes Contributors"]
 license = "MIT"
@@ -20,7 +20,6 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 rusqlite = { version = "0.31", features = ["bundled"] }
 uuid = { version = "1", features = ["v4", "serde"] }
-zip = { version = "2", default-features = false, features = ["deflate"] }
 thiserror = "1"
 chrono = { version = "0.4", features = ["serde"] }
 tauri-plugin-dialog = "2.6.0"
--- a/src-tauri/build.rs
+++ b/src-tauri/build.rs
@@ -1,21 +1,3 @@
 fn main() {
-    // Ensure sidecar.zip exists so tauri-build doesn't fail.
-    // CI replaces this placeholder with the real PyInstaller sidecar archive.
-    let zip_path = std::path::Path::new("sidecar.zip");
-    if !zip_path.exists() {
-        // Minimal valid zip (empty archive): end-of-central-directory record
-        let empty_zip: [u8; 22] = [
-            0x50, 0x4b, 0x05, 0x06, // EOCD signature
-            0x00, 0x00, // disk number
-            0x00, 0x00, // disk with central dir
-            0x00, 0x00, // entries on this disk
-            0x00, 0x00, // total entries
-            0x00, 0x00, 0x00, 0x00, // central dir size
-            0x00, 0x00, 0x00, 0x00, // central dir offset
-            0x00, 0x00, // comment length
-        ];
-        std::fs::write(zip_path, empty_zip).expect("Failed to create placeholder sidecar.zip");
-    }
-
    tauri_build::build()
 }
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -27,14 +27,6 @@ pub fn run() {
        .plugin(tauri_plugin_dialog::init())
        .manage(app_state)
        .setup(|app| {
-            // Tell the sidecar manager where Tauri placed bundled resources
-            // and where to extract the sidecar archive
-            if let (Ok(resource_dir), Ok(data_dir)) =
-                (app.path().resource_dir(), app.path().app_local_data_dir())
-            {
-                sidecar::init_dirs(resource_dir, data_dir);
-            }
-
            // Set the webview background to match the app's dark theme
            if let Some(window) = app.get_webview_window("main") {
                let _ = window.set_background_color(Some(Color(10, 10, 35, 255)));
--- a/src-tauri/src/sidecar/mod.rs
+++ b/src-tauri/src/sidecar/mod.rs
@@ -2,27 +2,11 @@ pub mod ipc;
 pub mod messages;

 use std::io::{BufRead, BufReader, Write};
-use std::path::{Path, PathBuf};
 use std::process::{Child, ChildStdin, Command, Stdio};
 use std::sync::{Mutex, OnceLock};

-#[cfg(target_os = "windows")]
-use std::os::windows::process::CommandExt;
-
 use crate::sidecar::messages::IPCMessage;

-/// Resource directory set by the Tauri app during setup.
-static RESOURCE_DIR: OnceLock<PathBuf> = OnceLock::new();
-/// App data directory for extracting the sidecar archive.
-static DATA_DIR: OnceLock<PathBuf> = OnceLock::new();
-
-/// Initialize directories for sidecar resolution.
-/// Must be called from the Tauri setup before any sidecar operations.
-pub fn init_dirs(resource_dir: PathBuf, data_dir: PathBuf) {
-    RESOURCE_DIR.set(resource_dir).ok();
-    DATA_DIR.set(data_dir).ok();
-}
-
 /// Get the global sidecar manager singleton.
 pub fn sidecar() -> &'static SidecarManager {
    static INSTANCE: OnceLock<SidecarManager> = OnceLock::new();
@@ -57,131 +41,37 @@ impl SidecarManager {
    }

    /// Resolve the frozen sidecar binary path (production mode).
-    ///
-    /// First checks if the sidecar is already extracted to the app data directory.
-    /// If not, looks for `sidecar.zip` in the Tauri resource directory and extracts it.
-    fn resolve_sidecar_path() -> Result<PathBuf, String> {
+    fn resolve_sidecar_path() -> Result<std::path::PathBuf, String> {
+        let exe = std::env::current_exe().map_err(|e| format!("Cannot get current exe: {e}"))?;
+        let exe_dir = exe
+            .parent()
+            .ok_or_else(|| "Cannot get exe parent directory".to_string())?;
+
        let binary_name = if cfg!(target_os = "windows") {
            "voice-to-notes-sidecar.exe"
        } else {
            "voice-to-notes-sidecar"
        };

-        // Versioned extraction directory prevents stale sidecar after app updates
-        let extract_dir = DATA_DIR
-            .get()
-            .ok_or("App data directory not initialized")?
-            .join(format!("sidecar-{}", env!("CARGO_PKG_VERSION")));
-
-        let binary_path = extract_dir.join(binary_name);
-
-        // Already extracted — use it directly
-        if binary_path.exists() {
-            return Ok(binary_path);
-        }
-
-        // Find sidecar.zip in resource dir or next to exe
-        let zip_path = Self::find_sidecar_zip()?;
-        Self::extract_zip(&zip_path, &extract_dir)?;
-
-        if !binary_path.exists() {
-            return Err(format!(
-                "Sidecar binary not found after extraction at {}",
-                binary_path.display()
-            ));
-        }
-
-        // Make executable on Unix
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            if let Ok(meta) = std::fs::metadata(&binary_path) {
-                let mut perms = meta.permissions();
-                perms.set_mode(0o755);
-                let _ = std::fs::set_permissions(&binary_path, perms);
-            }
-        }
-
-        Ok(binary_path)
-    }
-
-    /// Locate the bundled sidecar.zip archive.
-    fn find_sidecar_zip() -> Result<PathBuf, String> {
-        let mut candidates: Vec<PathBuf> = Vec::new();
-
-        if let Some(resource_dir) = RESOURCE_DIR.get() {
-            candidates.push(resource_dir.join("sidecar.zip"));
-        }
-        if let Ok(exe) = std::env::current_exe() {
-            if let Some(exe_dir) = exe.parent() {
-                candidates.push(exe_dir.join("sidecar.zip"));
-            }
-        }
-
-        for path in &candidates {
+        // Tauri places externalBin next to the app binary
+        let path = exe_dir.join(binary_name);
        if path.exists() {
-                return Ok(path.clone());
+            return Ok(path);
        }
+
+        // Also check inside a subdirectory (onedir PyInstaller output)
+        let subdir_path = exe_dir.join("voice-to-notes-sidecar").join(binary_name);
+        if subdir_path.exists() {
+            return Ok(subdir_path);
        }

        Err(format!(
-            "Sidecar archive not found. Checked:\n{}",
-            candidates
-                .iter()
-                .map(|p| format!("  {}", p.display()))
-                .collect::<Vec<_>>()
-                .join("\n"),
+            "Sidecar binary not found. Looked for:\n  {}\n  {}",
+            path.display(),
+            subdir_path.display(),
        ))
    }

-    /// Extract a zip archive to the given directory.
-    fn extract_zip(zip_path: &Path, dest: &Path) -> Result<(), String> {
-        eprintln!(
-            "[sidecar-rs] Extracting sidecar from {} to {}",
-            zip_path.display(),
-            dest.display()
-        );
-
-        // Clean destination so we don't mix old and new files
-        if dest.exists() {
-            std::fs::remove_dir_all(dest)
-                .map_err(|e| format!("Failed to clean extraction dir: {e}"))?;
-        }
-        std::fs::create_dir_all(dest)
-            .map_err(|e| format!("Failed to create extraction dir: {e}"))?;
-
-        let file =
-            std::fs::File::open(zip_path).map_err(|e| format!("Cannot open sidecar zip: {e}"))?;
-        let mut archive =
-            zip::ZipArchive::new(file).map_err(|e| format!("Invalid sidecar zip: {e}"))?;
-
-        for i in 0..archive.len() {
-            let mut entry = archive
-                .by_index(i)
-                .map_err(|e| format!("Zip entry error: {e}"))?;
-
-            let name = entry.name().to_string();
-            let outpath = dest.join(&name);
-
-            if entry.is_dir() {
-                std::fs::create_dir_all(&outpath)
-                    .map_err(|e| format!("Cannot create dir {}: {e}", outpath.display()))?;
-            } else {
-                if let Some(parent) = outpath.parent() {
-                    std::fs::create_dir_all(parent)
-                        .map_err(|e| format!("Cannot create dir {}: {e}", parent.display()))?;
-                }
-                let mut outfile = std::fs::File::create(&outpath)
-                    .map_err(|e| format!("Cannot create {}: {e}", outpath.display()))?;
-                std::io::copy(&mut entry, &mut outfile)
-                    .map_err(|e| format!("Write error for {}: {e}", name))?;
-            }
-        }
-
-        eprintln!("[sidecar-rs] Sidecar extracted successfully");
-        Ok(())
-    }
-
    /// Find a working Python command for the current platform.
    fn find_python_command() -> &'static str {
        if cfg!(target_os = "windows") {
@@ -224,8 +114,15 @@ impl SidecarManager {
        if Self::is_dev_mode() {
            self.start_python_dev()
        } else {
-            let path = Self::resolve_sidecar_path()?;
-            self.start_binary(&path)
+            match Self::resolve_sidecar_path() {
+                Ok(path) => self.start_binary(&path),
+                Err(e) => {
+                    eprintln!(
+                        "[sidecar-rs] Frozen binary not found ({e}), falling back to dev mode"
+                    );
+                    self.start_python_dev()
+                }
+            }
        }
    }

@@ -234,33 +131,10 @@ impl SidecarManager {
        self.stop().ok();
        eprintln!("[sidecar-rs] Starting frozen sidecar: {}", path.display());

-        // Log sidecar stderr to a file for diagnostics
-        let stderr_cfg = if let Some(data_dir) = DATA_DIR.get() {
-            let _ = std::fs::create_dir_all(data_dir);
-            let log_path = data_dir.join("sidecar.log");
-            eprintln!("[sidecar-rs] Sidecar stderr → {}", log_path.display());
-            match std::fs::File::create(&log_path) {
-                Ok(f) => Stdio::from(f),
-                Err(e) => {
-                    eprintln!("[sidecar-rs] Failed to create sidecar.log: {e}");
-                    Stdio::inherit()
-                }
-            }
-        } else {
-            eprintln!("[sidecar-rs] DATA_DIR not set, sidecar stderr will not be logged");
-            Stdio::inherit()
-        };
-
-        let mut cmd = Command::new(path);
-        cmd.stdin(Stdio::piped())
+        let child = Command::new(path)
+            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
-            .stderr(stderr_cfg);
-
-        // Hide the console window on Windows (CREATE_NO_WINDOW = 0x08000000)
-        #[cfg(target_os = "windows")]
-        cmd.creation_flags(0x08000000);
-
-        let child = cmd
+            .stderr(Stdio::inherit())
            .spawn()
            .map_err(|e| format!("Failed to start sidecar binary: {e}"))?;

@@ -326,22 +200,7 @@ impl SidecarManager {
                    .read_line(&mut line)
                    .map_err(|e| format!("Read error: {e}"))?;
                if bytes == 0 {
-                    // Try to get the exit code for diagnostics
-                    let exit_info = {
-                        let mut proc = self.process.lock().map_err(|e| e.to_string())?;
-                        if let Some(ref mut child) = *proc {
-                            match child.try_wait() {
-                                Ok(Some(status)) => format!(" (exit status: {status})"),
-                                _ => String::new(),
-                            }
-                        } else {
-                            String::new()
-                        }
-                    };
-                    return Err(format!(
-                        "Sidecar closed stdout before sending ready{exit_info}. \
-                         The Python sidecar may have crashed on startup — check app logs for details."
-                    ));
+                    return Err("Sidecar closed stdout before sending ready".to_string());
                }
                let trimmed = line.trim();
                if trimmed.is_empty() {
@@ -371,46 +230,11 @@ impl SidecarManager {

    /// Send a message and receive the response, calling a callback for intermediate messages.
    /// Intermediate messages include progress, pipeline.segment, and pipeline.speaker_update.
-    ///
-    /// If the sidecar has crashed (broken pipe), automatically restarts it and retries once.
    pub fn send_and_receive_with_progress<F>(
        &self,
        msg: &IPCMessage,
        on_intermediate: F,
    ) -> Result<IPCMessage, String>
-    where
-        F: Fn(&IPCMessage),
-    {
-        match self.send_and_receive_inner(msg, &on_intermediate) {
-            Ok(response) => Ok(response),
-            Err(e)
-                if e.contains("Write error")
-                    || e.contains("closed stdout")
-                    || e.contains("not available") =>
-            {
-                eprintln!("[sidecar-rs] Sidecar communication failed ({e}), restarting...");
-                self.cleanup_handles();
-                // Stop any zombie process
-                {
-                    let mut proc = self.process.lock().map_err(|e| e.to_string())?;
-                    if let Some(ref mut child) = proc.take() {
-                        let _ = child.kill();
-                        let _ = child.wait();
-                    }
-                }
-                self.ensure_running()?;
-                self.send_and_receive_inner(msg, &on_intermediate)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Inner implementation of send_and_receive.
-    fn send_and_receive_inner<F>(
-        &self,
-        msg: &IPCMessage,
-        on_intermediate: &F,
-    ) -> Result<IPCMessage, String>
    where
        F: Fn(&IPCMessage),
    {
@@ -496,39 +320,8 @@ impl SidecarManager {
    }

    pub fn is_running(&self) -> bool {
-        let mut proc = match self.process.lock() {
-            Ok(p) => p,
-            Err(_) => return false,
-        };
-        if let Some(ref mut child) = *proc {
-            // Check if the process has exited
-            match child.try_wait() {
-                Ok(Some(_status)) => {
-                    // Process has exited — clean up handles
-                    eprintln!("[sidecar-rs] Sidecar process has exited");
-                    drop(proc);
-                    let _ = self.cleanup_handles();
-                    false
-                }
-                Ok(None) => true, // Still running
-                Err(_) => false,
-            }
-        } else {
-            false
-        }
-    }
-
-    /// Clean up stdin/stdout/process handles after the sidecar has exited.
-    fn cleanup_handles(&self) {
-        if let Ok(mut s) = self.stdin.lock() {
-            *s = None;
-        }
-        if let Ok(mut r) = self.reader.lock() {
-            *r = None;
-        }
-        if let Ok(mut p) = self.process.lock() {
-            *p = None;
-        }
+        let proc = self.process.lock().ok();
+        proc.map_or(false, |p| p.is_some())
    }
 }

--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "Voice to Notes",
-  "version": "0.2.5",
+  "version": "0.1.0",
  "identifier": "com.voicetonotes.app",
  "build": {
    "beforeDevCommand": "npm run dev",
@@ -31,7 +31,7 @@
  },
  "bundle": {
    "active": true,
-    "targets": ["deb", "nsis", "msi", "dmg"],
+    "targets": "all",
    "icon": [
      "icons/32x32.png",
      "icons/128x128.png",
@@ -42,12 +42,14 @@
    "category": "Utility",
    "shortDescription": "Transcribe audio/video with speaker identification",
    "longDescription": "Voice to Notes is a desktop application that transcribes audio and video recordings with speaker identification, synchronized playback, and AI-powered analysis. Export to SRT, WebVTT, ASS captions, or plain text.",
-    "resources": ["sidecar.zip"],
    "copyright": "Voice to Notes Contributors",
    "license": "MIT",
    "linux": {
      "deb": {
        "depends": []
+      },
+      "appimage": {
+        "bundleMediaFramework": true
      }
    },
    "windows": {