Deployment & Operations

cp .env.example .env
# then fill SLACK_*, ANTHROPIC_*, SLAUDE_MODEL

# OpenRouter
ANTHROPIC_BASE_URL=https://openrouter.ai/api/v1
ANTHROPIC_API_KEY=sk-or-...
SLAUDE_MODEL=anthropic/claude-sonnet-4

# Z.ai
ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic
ANTHROPIC_API_KEY=...
SLAUDE_MODEL=claude-sonnet-4-20250514

# Self-hosted gateway
ANTHROPIC_BASE_URL=https://llm.internal.example.com
ANTHROPIC_AUTH_TOKEN=...
SLAUDE_MODEL=claude-sonnet-4

$SLAUDE_HOME/
  SOUL.md            # persona — operator-authored, required
  .env               # optional dotenv (loaded before process env)
  .mcp.json          # external MCP servers (supports ${VAR} substitution)
  slaude.json        # dependency manifest (skills / KB)
  slaude.lock        # pinned SHAs
  db.sqlite (+ -wal/-shm)   # sessions, cron, ignores, locks
  workspaces/        # per-thread cwd
  skills/            # installed skills
  knowledge/         # installed KB wikis
  cache/             # extracted SoulData + policy embeddings
  .claude/           # Claude Code config + OAuth creds (file-based on Linux)

git clone https://github.com/barockok/slaude.git && cd slaude
cp .env.example .env          # fill SLACK_* + ANTHROPIC_*
mkdir -p data                 # will be mounted as /data = $SLAUDE_HOME
cat > data/SOUL.md <<'MD'
# Soul

I am slaude — your team mate.

## Mandate
...

## Manager
@zidni — Slack user ID U...

## Approvers
- U... (manager)
MD

# docker-compose.yaml (abridged — see repo for full file)
services:
  slaude:
    build: .
    image: slaude:latest
    container_name: slaude
    restart: unless-stopped
    environment:
      SLAUDE_HOME: /data
      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
      SLACK_APP_TOKEN: ${SLACK_APP_TOKEN}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
      ANTHROPIC_BASE_URL: ${ANTHROPIC_BASE_URL:-}
      SLAUDE_MODEL: ${SLAUDE_MODEL:-claude-sonnet-4-6}
      GRAFANA_URL: ${GRAFANA_URL:-}
      GRAFANA_API_KEY: ${GRAFANA_API_KEY:-}
    volumes:
      - ./data:/data

docker compose build
docker compose up -d
docker compose logs -f slaude

[slaude] health server on :8080
[slaude] slack socket mode started

curl -s http://localhost:8080/healthz | jq .
# {"status":"ok","uptime_ms":12345,"sessions_live":0}

curl -s http://localhost:8080/readyz | jq .
# {"status":"ready"}   — 503 {"status":"unready","error":"..."} if DB unreachable

curl -s http://localhost:8080/metrics | head -20
# # HELP slaude_sessions_live Number of live SDK sessions in this process.
# # TYPE slaude_sessions_live gauge
# slaude_sessions_live 0

git pull
docker compose build
docker compose up -d          # recreates container, volume preserved

# Edit the Secret + ConfigMap first
vim deploy/k8s/slaude.yaml
#  - Secret/slaude-secrets:  replace REPLACE_xoxb / REPLACE_xapp / REPLACE_sk-ant
#  - ConfigMap/slaude-config: paste the persona SOUL.md under SOUL.md: |
#  - Deployment: set image: ghcr.io/<owner>/slaude:<tag>

kubectl apply -f deploy/k8s/slaude.yaml
kubectl -n slaude rollout status deploy/slaude
kubectl -n slaude logs -f deploy/slaude

livenessProbe:
  httpGet: { path: /healthz, port: health }   # :8080 — always 200 when process is up
  initialDelaySeconds: 10
  periodSeconds: 30
readinessProbe:
  httpGet: { path: /readyz, port: health }    # :8080 — 200 only if DB reachable (SELECT 1)
  initialDelaySeconds: 5
  periodSeconds: 10

resources:
  requests: { cpu: "100m", memory: "256Mi" }
  limits:   { cpu: "1000m", memory: "1Gi" }

# persona: hermes — customer-facing agent
kubectl apply -f deploy/k8s/slaude-hermes.yaml   # namespace: slaude-hermes
# persona: maria — internal agent
kubectl apply -f deploy/k8s/slaude-maria.yaml    # namespace: slaude-maria

metadata:
  labels: { app: slaude, persona: hermes }
spec:
  template:
    metadata:
      labels: { app: slaude, persona: hermes }

# Option A — update image tag in place
kubectl -n slaude set image deploy/slaude slaude=ghcr.io/<owner>/slaude:v0.42.0
kubectl -n slaude rollout status deploy/slaude

# Option B — re-apply the manifest after editing SOUL.md / ConfigMap
kubectl apply -f deploy/k8s/slaude.yaml
kubectl -n slaude rollout restart deploy/slaude

SLAUDE_HEALTH_PORT=8080   # default; 0 disables the server entirely

# prometheus.yml
scrape_configs:
  - job_name: slaude
    static_configs:
      - targets: ["slaude:8080"]

SLAUDE_METRICS_LABELS="agent=hermes,env=prod"
SLAUDE_METRICS_PER_USER=1   # opt-in: emit user_id/user_name on slaude_user_turns_total

curl -fsSL https://raw.githubusercontent.com/barockok/slaude/main/install.sh | bash
# Env overrides:
#   SLAUDE_VERSION=x.y.z    pin a release (without v prefix)
#   SLAUDE_DIST=~/.slaude-dist
#   SLAUDE_BIN_DIR=~/.local/bin
#   SLAUDE_NO_BOOTSTRAP=1   skip bun/uv auto-install

# Ensure ~/.local/bin is on PATH
export PATH="$HOME/.local/bin:$PATH"

git clone https://github.com/barockok/slaude.git && cd slaude
bun install
bun run link
# links bin/slaude.ts → ~/.bun/bin/slaude (ensure ~/.bun/bin is on PATH)

# $SLAUDE_HOME resolves to: $SLAUDE_HOME > ./SOUL.md dir > ~/.slaude
slaude start              # boot the Slack runtime (or bare `slaude`)
slaude sim                # local sim REPL (Slack-free verification)
slaude brain-server       # standalone brain MCP server
slaude brain connect      # OAuth-bootstrap a remote brain link

# Self-management (built into bin/slaude.ts)
slaude version            # prints active vs latest: "slaude 0.41.0 (latest: 0.41.0)"
slaude update             # fetch latest, verify checksum, swap current, prune old
slaude rollback           # swap back to previous version
slaude --help             # usage

git pull
docker compose build
docker compose up -d
docker compose logs -f slaude | grep -E "health server|slack socket|ready"

kubectl -n slaude set image deploy/slaude slaude=ghcr.io/<owner>/slaude:v0.42.0
kubectl -n slaude rollout status deploy/slaude
# or re-apply the manifest after editing SOUL.md
kubectl apply -f deploy/k8s/slaude.yaml
kubectl -n slaude rollout restart deploy/slaude

slaude update             # latest stable
SLAUDE_VERSION=0.42.0 slaude update   # pinned
slaude version            # verify
# if broken:
slaude rollback

SLAUDE_VERSION=0.42.0-rc.1 bash install.sh   # explicit RC install
# soak, then maintainer promotes:
scripts/promote-rc.sh v0.42.0-rc.1           # bumps to v0.42.0 stable

[slaude] health server on :8080
[persona] multi-persona mode: hermes, maria   # only in multi-persona mode
[slaude] slack socket mode started

# SQLite backup — use the sqlite3 backup API for a consistent snapshot,
# or copy all three files while the container is stopped.
docker compose stop slaude
cp -a data/db.sqlite* /backups/slaude-$(date +%F)/
cp -a data/SOUL.md data/.mcp.json data/slaude.json data/slaude.lock /backups/slaude-$(date +%F)/
docker compose start slaude

# Or hot-backup via sqlite3 (no downtime):
docker compose exec slaude sqlite3 /data/db.sqlite ".backup /data/db-hot.sqlite"
docker cp slaude:/data/db-hot.sqlite ./db-$(date +%F).sqlite

# PVC snapshot (requires VolumeSnapshot support)
kubectl apply -f - <<'YAML'
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata: { name: slaude-data-snap, namespace: slaude }
spec: { source: { persistentVolumeClaimName: slaude-data } }
YAML

# Or copy files out
kubectl -n slaude exec deploy/slaude -- tar -czf - -C /data db.sqlite* SOUL.md .mcp.json slaude.json slaude.lock \
  | tar -xzf - -C ./restore-$(date +%F)/

# Docker Compose
docker compose down
cp -a /backups/slaude-2026-08-24/* data/
docker compose up -d

# Kubernetes — restore into a new PVC or copy back via kubectl cp
kubectl -n slaude cp ./restore-2026-08-24/db.sqlite slaude-xxx:/data/db.sqlite
kubectl -n slaude rollout restart deploy/slaude

# Docker
docker compose ps                          # container up?
docker compose logs --tail 50 slaude       # boot errors?
curl -sf http://localhost:8080/healthz    # liveness
curl -sf http://localhost:8080/readyz     # readiness (DB)
curl -sf http://localhost:8080/metrics | grep slaude_errors_total

# Kubernetes
kubectl -n slaude get pods                 # pod Running?
kubectl -n slaude describe pod -l app=slaude   # probe failures, OOMKilled?
kubectl -n slaude logs --tail 50 -l app=slaude
kubectl -n slaude exec deploy/slaude -- ls -lh /data/

# Bare metal
ls -lh ~/.slaude/db.sqlite* ~/.slaude/SOUL.md
cat ~/.slaude/.env | grep -v TOKEN         # verify env without leaking secrets
slaude version
curl -sf http://localhost:8080/healthz