> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olis-ai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Building

> Build the Olis applications for production

## 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:

```bash theme={null}
# 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

<Steps>
  <Step title="Build Next.js renderer">
    ```bash theme={null}
    cd apps/electron-client
    pnpm run build
    ```

    This creates a static export in `out/` directory.
  </Step>

  <Step title="Compile Electron main process">
    ```bash theme={null}
    pnpm run build:electron
    ```

    Compiles TypeScript to JavaScript in `dist-electron/`.
  </Step>

  <Step title="Package installers">
    ```bash theme={null}
    pnpm run package
    ```

    Creates platform-specific installers in `release/`:

    * Windows: `.exe` installer
    * macOS: `.dmg`, `.zip`
    * Linux: `.AppImage`, `.snap`, `.deb`
  </Step>
</Steps>

### Platform-Specific Builds

<Tabs>
  <Tab title="Windows">
    ```bash theme={null}
    # 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)
  </Tab>

  <Tab title="macOS">
    ```bash theme={null}
    # On macOS machine
    pnpm run package:mac

    # Artifacts in release/
    # - Olis-X.X.X.dmg
    # - Olis-X.X.X-mac.zip
    ```

    **Requirements**:

    * macOS 10.13+
    * Xcode Command Line Tools
    * Code signing certificate (for distribution)
  </Tab>

  <Tab title="Linux">
    ```bash theme={null}
    # On Linux machine
    pnpm run package:linux

    # Artifacts in release/
    # - Olis-X.X.X.AppImage
    # - Olis-X.X.X.snap
    # - olis_X.X.X_amd64.deb
    ```

    **Requirements**:

    * Ubuntu 20.04+ or similar
    * `build-essential` package
  </Tab>
</Tabs>

## API Server

### Docker Build

```bash theme={null}
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

```bash theme={null}
cd apps/api-server

# Build wheel
python setup.py bdist_wheel

# Or with poetry
poetry build
```

## Chrome Extension

```bash theme={null}
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

<AccordionGroup>
  <Accordion title="Bundle Size Optimization">
    ```javascript theme={null}
    // 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
      }
    }
    ```
  </Accordion>

  <Accordion title="Asset Optimization">
    * Compress images with imagemin
    * Use SVG for icons when possible
    * Lazy load heavy components
    * Code split routes
  </Accordion>

  <Accordion title="Electron Builder Optimization">
    ```json5 theme={null}
    // electron-builder.json5
    {
      "compression": "maximum",
      "asar": true,
      "asarUnpack": [
        "native/**/*",
        "local-llm/**/*"
      ],
      "files": [
        "out/**/*",
        "dist-electron/**/*",
        "!**/*.ts",
        "!**/*.map"
      ]
    }
    ```
  </Accordion>
</AccordionGroup>

### API Server

<AccordionGroup>
  <Accordion title="Multi-stage Docker Build">
    ```dockerfile theme={null}
    # 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"]
    ```
  </Accordion>

  <Accordion title="Python Optimization">
    ```python theme={null}
    # 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)
    ```
  </Accordion>
</AccordionGroup>

## CI/CD Pipeline

### GitHub Actions Example

```yaml theme={null}
# .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

```bash theme={null}
# 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

```bash theme={null}
# 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

<Steps>
  <Step title="Update version">
    ```bash theme={null}
    # Update version in package.json
    pnpm version patch  # or minor, major

    # Update version in Python pyproject.toml
    # Update version in manifest.json for extension
    ```
  </Step>

  <Step title="Build all applications">
    ```bash theme={null}
    pnpm run build
    ```
  </Step>

  <Step title="Run tests">
    ```bash theme={null}
    pnpm test
    pnpm lint
    ```
  </Step>

  <Step title="Create git tag">
    ```bash theme={null}
    git tag -a v0.1.0 -m "Release v0.1.0"
    git push origin v0.1.0
    ```
  </Step>

  <Step title="Upload to distribution platforms">
    * GitHub Releases
    * Chrome Web Store
    * Mac App Store (optional)
    * Microsoft Store (optional)
  </Step>
</Steps>

## Next Steps

<CardGroup cols={2}>
  <Card title="Testing" icon="flask" href="/development/testing">
    Write and run tests
  </Card>

  <Card title="Contributing" icon="hand-holding-heart" href="/development/contributing">
    Contribution guidelines
  </Card>
</CardGroup>