Refactor to build web-app locally before deployment

Changes build strategy from building on target machines to building
locally and deploying pre-built artifacts. This simplifies target
machine configuration and improves deployment speed.

- Add build-local.nix for local machine-specific builds
- Update krops.nix to deploy built artifacts from ./build/{machine}/dist
- Remove build-helper.nix and build dependencies from machine configs
- Update documentation with new build-then-deploy workflow
- Add .gitignore for build directories

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,4 @@
+build/
+node_modules/
+dist/
+result

DEPLOYMENT-GUIDE.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-This setup allows each machine to build the web-app with its own specific configuration:
+This setup builds the web-app **locally** with machine-specific configuration, then deploys the built artifacts to each target machine. Each machine gets its own customized build with:
 - Machine-specific `.env` files
 - Machine-specific images in the `public` folder
 
@@ -13,7 +13,7 @@ This setup allows each machine to build the web-app with its own specific config
 ├── web-app/                          # Shared web-app source code
 │   ├── package.json
 │   ├── index.html
-│   └── public/                       # Images will be copied here during build
+│   └── public/                       # Base public folder
 ├── machine-specific/
 │   ├── machine1/
 │   │   ├── env/.env                  # Machine1's environment file
@@ -25,49 +25,56 @@ This setup allows each machine to build the web-app with its own specific config
 │       └── images/                   # Machine2's images
 │           ├── logo.png
 │           └── banner.jpg
-└── build-helper.nix                  # Build script available on target machines
+├── build/                            # Generated locally (gitignored)
+│   ├── machine1/dist/                # Built files for machine1
+│   └── machine2/dist/                # Built files for machine2
+├── build-local.nix                   # Local build scripts
+└── krops.nix                         # Deployment configuration
 ```
 
 ## How It Works
 
-### 1. Krops Deployment (krops.nix)
+### 1. Build Locally
 
-When you deploy with krops, it copies to each target machine:
+First, build the web-app for each machine **on your local machine**:
-- `web-app` → `/var/src/web-app` (shared source code)
-- `machine-specific/{name}/env/.env` → `/var/src/web-app-env` (machine-specific .env)
-- `machine-specific/{name}/images/` → `/var/src/web-app-images/` (machine-specific images)
-
-### 2. Building on Target Machine
-
-After deployment, SSH into the target machine and run:
 
 ```bash
-build-web-app
+# Build for a specific machine
+nix-build ./build-local.nix -A machine1 && ./result/bin/build-machine1
+
+# Or build for all machines
+nix-build ./build-local.nix -A all && ./result/bin/build-all
 ```
 
-This script:
+This:
-1. Copies the machine-specific `.env` file to the web-app directory
+1. Copies web-app source to `./build/{machine}/`
-2. Copies the machine-specific images to `web-app/public/`
+2. Copies machine-specific `.env` file
-3. Runs `npm run build` to build the web-app
+3. Copies machine-specific images to `public/`
+4. Runs `npm run build`
+5. Creates `./build/{machine}/dist/` with the built app
 
-The build output will be in `/var/src/web-app/dist/`
+### 2. Deploy Built Artifacts
 
-## Usage
+After building, deploy to target machines:
 
-### Deploy to a single machine:
 ```bash
+# Deploy to specific machine
 nix-build ./krops.nix -A machine1 && ./result
-```
 
-### Deploy to all machines:
+# Deploy to all machines
-```bash
 nix-build ./krops.nix -A all && ./result
 ```
 
-### Build the web-app on target machine:
+The built files from `./build/{machine}/dist/` are copied to `/var/src/web-app-dist/` on each target machine.
+
+## Complete Workflow
+
 ```bash
-ssh root@machine1.example.com
+# 1. Build locally for all machines
-build-web-app
+nix-build ./build-local.nix -A all && ./result/bin/build-all
+
+# 2. Deploy to all machines
+nix-build ./krops.nix -A all && ./result
 ```
 
 ## Customization
@@ -76,12 +83,15 @@ build-web-app
 1. Create directories: `machine-specific/machine3/env/` and `machine-specific/machine3/images/`
 2. Add `.env` file and images for machine3
 3. Create `config/machine3/configuration.nix`
-4. Add machine3 target in `krops.nix`
+4. Add machine3 to `build-local.nix` and `krops.nix`
 
 ### Update environment variables:
-Edit the appropriate `.env` file in `machine-specific/{machine-name}/env/.env`
+Edit `.env` in `machine-specific/{machine-name}/env/.env`, then rebuild locally
 
 ### Update images:
-Replace files in `machine-specific/{machine-name}/images/`
+Replace files in `machine-specific/{machine-name}/images/`, then rebuild locally
 
-After making changes, redeploy with krops.
+### Update web-app code:
+Edit files in `web-app/`, then rebuild locally
+
+After any changes: rebuild locally, then redeploy.

build-helper.nix

@@ -1,29 +0,0 @@
-# Helper script for building the web-app on target machines
-# This can be imported into the machine's configuration.nix
-
-{ pkgs }:
-
-pkgs.writeShellScriptBin "build-web-app" ''
-  set -e
-
-  # Web-app sources are deployed to /var/src by krops
-  WEB_APP_DIR="/var/src/web-app"
-  ENV_FILE="/var/src/web-app-env"
-  IMAGES_DIR="/var/src/web-app-images"
-
-  cd "$WEB_APP_DIR"
-
-  # Copy machine-specific .env file
-  echo "Copying machine-specific .env file..."
-  cp "$ENV_FILE" .env
-
-  # Copy machine-specific images to public folder
-  echo "Copying machine-specific images..."
-  cp -r "$IMAGES_DIR"/* public/
-
-  # Build the web-app
-  echo "Building web-app..."
-  ${pkgs.nodejs}/bin/npm run build
-
-  echo "Build complete! Output in $WEB_APP_DIR/dist"
-''