Skip to main content

​
Overview

This guide covers building all Olis applications for production deployment, including optimization strategies and platform-specific considerations.

​
Build All Applications

From the repository root: 
# Build all applications
pnpm run build

# Or with Nx
pnpm nx run-many --target=build --all

# Build specific apps
pnpm nx build electron-client
pnpm nx build api-server
pnpm nx build chrome-extension

​
Electron Desktop Client

1

Build Next.js renderer

cd apps/electron-client
pnpm run build
This creates a static export in out/ directory.
2

Compile Electron main process

pnpm run build:electron
Compiles TypeScript to JavaScript in dist-electron/.
3

Package installers

pnpm run package
Creates platform-specific installers in release/:
  • Windows: .exe installer
  • macOS: .dmg, .zip
  • Linux: .AppImage, .snap, .deb

​
Platform-Specific Builds

# On Windows machine
pnpm run package:win

# Artifacts in release/
# - Olis Setup X.X.X.exe
Requirements:
  • Windows 10+ (for building)
  • NSIS (included with electron-builder)

​
API Server

​
Docker Build

cd apps/api-server

# Build Docker image
docker build -t olis-api:latest .

# Tag for registry
docker tag olis-api:latest registry.example.com/olis-api:latest

# Push to registry
docker push registry.example.com/olis-api:latest

​
Python Package

cd apps/api-server

# Build wheel
python setup.py bdist_wheel

# Or with poetry
poetry build

​
Chrome Extension

cd apps/chrome-extension

# Production build
pnpm run build

# Create ZIP for Chrome Web Store
cd dist
zip -r ../olis-extension.zip .
cd ..

​
Build Optimization

​
Electron Client

// next.config.mjs
const nextConfig = {
  // Enable SWC minification
  swcMinify: true,

  // Disable source maps in production
  productionBrowserSourceMaps: false,

  // Optimize images
  images: {
    unoptimized: false,
    minimumCacheTTL: 60,
  },

  // Bundle analyzer (optional)
  webpack: (config, { isServer }) => {
    if (!isServer) {
      config.optimization.splitChunks = {
        chunks: 'all',
      }
    }
    return config
  }
}
  • Compress images with imagemin
  • Use SVG for icons when possible
  • Lazy load heavy components
  • Code split routes
// electron-builder.json5
{
  "compression": "maximum",
  "asar": true,
  "asarUnpack": [
    "native/**/*",
    "local-llm/**/*"
  ],
  "files": [
    "out/**/*",
    "dist-electron/**/*",
    "!**/*.ts",
    "!**/*.map"
  ]
}

​
API Server

# Build stage
FROM python:3.11-slim as builder

WORKDIR /app
COPY requirements.txt .

# Install dependencies
RUN pip install --user --no-cache-dir -r requirements.txt

# Production stage
FROM python:3.11-slim

WORKDIR /app

# Copy dependencies from builder
COPY --from=builder /root/.local /root/.local

# Copy application
COPY . .

# Make sure scripts are in PATH
ENV PATH=/root/.local/bin:$PATH

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# Use uvloop for better async performance
import uvloop
uvloop.install()

# Use orjson for faster JSON
from fastapi.responses import ORJSONResponse

app = FastAPI(default_response_class=ORJSONResponse)

​
CI/CD Pipeline

​
GitHub Actions Example

# .github/workflows/build.yml
name: Build Applications

on:
  push:
    branches: [main, dev]
  pull_request:
    branches: [main]

jobs:
  build-electron:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18

      - name: Setup pnpm
        uses: pnpm/action-setup@v2
        with:
          version: 9.15.4

      - name: Install dependencies
        run: pnpm install

      - name: Build Electron app
        run: |
          cd apps/electron-client
          pnpm run build
          pnpm run build:electron
          pnpm run package

      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: electron-${{ matrix.os }}
          path: apps/electron-client/release/

  build-api:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Build Docker image
        run: |
          cd apps/api-server
          docker build -t olis-api:${{ github.sha }} .

      - name: Push to registry
        if: github.ref == 'refs/heads/main'
        run: |
          echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
          docker push olis-api:${{ github.sha }}

​
Code Signing

​
macOS Code Signing

# Install certificate
security import certificate.p12 -k ~/Library/Keychains/login.keychain

# Configure electron-builder
export CSC_LINK=/path/to/certificate.p12
export CSC_KEY_PASSWORD=your-password

# Build with code signing
pnpm run package:mac

​
Windows Code Signing

# Using SignTool
signtool sign /f certificate.pfx /p password /t http://timestamp.digicert.com /fd sha256 "Olis Setup.exe"

# Or configure electron-builder
export WIN_CSC_LINK=/path/to/certificate.pfx
export WIN_CSC_KEY_PASSWORD=your-password

pnpm run package:win

​
Release Process

1

Update version

# Update version in package.json
pnpm version patch  # or minor, major

# Update version in Python pyproject.toml
# Update version in manifest.json for extension
2

Build all applications

pnpm run build
3

Run tests

pnpm test
pnpm lint
4

Create git tag

git tag -a v0.1.0 -m "Release v0.1.0"
git push origin v0.1.0
5

Upload to distribution platforms

  • GitHub Releases
  • Chrome Web Store
  • Mac App Store (optional)
  • Microsoft Store (optional)

​
Next Steps

Testing

Write and run tests

Contributing

Contribution guidelines