all:
  children:
    infra:
      hosts:
        10.10.10.10:
          # VIBE config
          vibe_data: /fs
          code_enabled: true
          jupyter_enabled: true
          claude_enabled: true

code_enabled: true           # Enable Code-Server
code_port: 8443              # Listen port (localhost only)
code_data: /data/code        # User data directory
code_password: 'Code.Server' # Login password
code_gallery: openvsx        # Extension marketplace

# Use Microsoft extension marketplace
code_enabled: true
code_password: 'MySecretPassword'
code_gallery: microsoft
code_data: /data/code

jupyter_enabled: true           # Enable JupyterLab
jupyter_port: 8888              # Listen port
jupyter_data: /data/jupyter     # Data directory
jupyter_password: 'Jupyter.Lab' # Login Token
jupyter_venv: /data/venv        # Python venv path

# Create venv
python3 -m venv /data/venv

# Install JupyterLab (VIBE playbook auto-installs)
/data/venv/bin/pip install jupyterlab ipykernel

# Custom JupyterLab config
jupyter_enabled: true
jupyter_password: 'MySecretToken'
jupyter_port: 8888
jupyter_data: /data/jupyter
jupyter_venv: /data/venv

claude_enabled: true   # Enable Claude Code
claude_env: {}         # Extra environment variables

claude_enabled: true
claude_env:
  ANTHROPIC_API_KEY: sk-ant-xxx-your-api-key

# Set env var
export ANTHROPIC_API_KEY=sk-ant-xxx-your-api-key

# Or use Claude Code config command
claude config set apiKey sk-ant-xxx-your-api-key

vibe_data: /fs   # Default uses JuiceFS mount point

all:
  children:
    infra:
      hosts:
        10.10.10.10:
          code_enabled: true

all:
  children:
    infra:
      hosts:
        10.10.10.10:
          # Working directory
          vibe_data: /fs

          # Code-Server
          code_enabled: true
          code_port: 8443
          code_password: 'Code.Server'
          code_gallery: openvsx

          # JupyterLab
          jupyter_enabled: true
          jupyter_port: 8888
          jupyter_password: 'Jupyter.Lab'
          jupyter_venv: /data/venv

          # Claude Code
          claude_enabled: true
          claude_env:
            ANTHROPIC_API_KEY: sk-ant-xxx

all:
  vars:
    version: v3.4.0
    admin_ip: 10.10.10.10
    infra_portal:
      home: { domain: h.pigsty }
      grafana: { domain: g.pigsty, endpoint: "${admin_ip}:3000" }
      prometheus: { domain: p.pigsty, endpoint: "${admin_ip}:9090" }
      alertmanager: { domain: a.pigsty, endpoint: "${admin_ip}:9093" }
      code: { domain: code.pigsty, endpoint: "127.0.0.1:8443", websocket: true }
      jupyter: { domain: jupyter.pigsty, endpoint: "127.0.0.1:8888", websocket: true }

    # PostgreSQL config
    pg_cluster: pg-meta
    pg_databases:
      - name: meta

    # JuiceFS config
    juice_instances:
      jfs:
        path: /fs
        meta: postgres://dbuser_meta:[email protected]:5432/meta
        data: --storage postgres --bucket postgres://dbuser_meta:[email protected]:5432/meta?prefix=juice

  children:
    infra:
      hosts:
        10.10.10.10:
          # VIBE config
          vibe_data: /fs
          code_enabled: true
          code_password: 'YourSecurePassword'
          jupyter_enabled: true
          jupyter_password: 'YourSecureToken'
          claude_enabled: true
          claude_env:
            ANTHROPIC_API_KEY: sk-ant-xxx

# Only enable Code-Server
code_enabled: true
jupyter_enabled: false
claude_enabled: false

# Only enable JupyterLab
code_enabled: false
jupyter_enabled: true
claude_enabled: false

# Only enable Claude Code
code_enabled: false
jupyter_enabled: false
claude_enabled: true

./vibe.yml -l <host> -e code_enabled=false
./vibe.yml -l <host> -e jupyter_enabled=false
./vibe.yml -l <host> -e claude_enabled=false

infra_portal:
  # Sub-path mode (default)
  home: { domain: h.pigsty }

  # Sub-domain mode (optional)
  code: { domain: code.pigsty, endpoint: "127.0.0.1:8443", websocket: true }
  jupyter: { domain: jupyter.pigsty, endpoint: "127.0.0.1:8888", websocket: true }

vibe_data: /fs              # Default, JuiceFS mount point
vibe_data: /home/dev/work   # Custom working directory

code_enabled: true   # Enabled (default)
code_enabled: false  # Disabled

code_port: 8443   # Default port
code_port: 9443   # Custom port

code_data: /data/code      # Default path
code_data: /home/dev/code  # Custom path

code_password: 'Code.Server'     # Default (change it!)
code_password: 'MySecretPass!'   # Custom password

code_gallery: openvsx    # Open VSX (default)
code_gallery: microsoft  # Microsoft marketplace

jupyter_enabled: true   # Enabled (default)
jupyter_enabled: false  # Disabled

jupyter_port: 8888   # Default port
jupyter_port: 8899   # Custom port

jupyter_data: /data/jupyter      # Default path
jupyter_data: /home/dev/jupyter  # Custom path

jupyter_password: 'Jupyter.Lab'   # Default (change it!)
jupyter_password: 'MySecretToken' # Custom Token

jupyter_venv: /data/venv          # Default path
jupyter_venv: /home/dev/.venv     # Custom path

claude_enabled: true   # Enabled (default)
claude_enabled: false  # Disabled

# Configure API Key
claude_env:
  ANTHROPIC_API_KEY: sk-ant-xxx-your-api-key

# Configure custom API endpoint
claude_env:
  ANTHROPIC_API_KEY: sk-ant-xxx
  ANTHROPIC_BASE_URL: https://api.example.com

all:
  children:
    infra:
      hosts:
        10.10.10.10:
          code_enabled: true
          code_password: 'Password1'
        10.10.10.11:
          code_enabled: true
          code_password: 'Password2'

# VIBE common params
vibe_data: /fs

# Code-Server params
code_enabled: true
code_port: 8443
code_data: /data/code
code_password: 'Code.Server'
code_gallery: openvsx

# JupyterLab params
jupyter_enabled: true
jupyter_port: 8888
jupyter_data: /data/jupyter
jupyter_password: 'Jupyter.Lab'
jupyter_venv: /data/venv

# Claude Code params
claude_enabled: true
claude_env: {}

- name: Deploy VIBE development environment
  hosts: all
  become: yes
  gather_facts: no
  roles:
    - { role: node_id, tags: id }
    - { role: vibe, tags: vibe }

# Full deployment (all components)
./vibe.yml -l <host>

# Deploy Code-Server only
./vibe.yml -l <host> -t code

# Deploy JupyterLab only
./vibe.yml -l <host> -t jupyter

# Deploy Claude Code only
./vibe.yml -l <host> -t claude

# Disable specific component
./vibe.yml -l <host> -e code_enabled=false
./vibe.yml -l <host> -e jupyter_enabled=false
./vibe.yml -l <host> -e claude_enabled=false

# Configure Claude API Key
./vibe.yml -l <host> -e claude_env.ANTHROPIC_API_KEY=sk-ant-xxx

./vibe.yml -l <host> -t vibe_dir

./vibe.yml -l <host> -t claude

./vibe.yml -l <host> -t code

./vibe.yml -l <host> -t jupyter

# Deploy on single host
./vibe.yml -l 10.10.10.10

# Deploy on multiple hosts
./vibe.yml -l '10.10.10.10,10.10.10.11'

# Deploy on specified group
./vibe.yml -l infra

# Deploy Code-Server only
./vibe.yml -l <host> -t code

# Deploy JupyterLab only
./vibe.yml -l <host> -t jupyter

# Deploy Claude Code only
./vibe.yml -l <host> -t claude

# Update Code-Server config and restart
./vibe.yml -l <host> -t code_config,code_launch

# Update JupyterLab config and restart
./vibe.yml -l <host> -t jupyter_config,jupyter_launch

# Update Claude Code config
./vibe.yml -l <host> -t claude_config

# Restart Code-Server
./vibe.yml -l <host> -t code_launch

# Restart JupyterLab
./vibe.yml -l <host> -t jupyter_launch

# Custom password
./vibe.yml -l <host> -e code_password='MyPassword'
./vibe.yml -l <host> -e jupyter_password='MyToken'

# Disable component
./vibe.yml -l <host> -e code_enabled=false
./vibe.yml -l <host> -e jupyter_enabled=false
./vibe.yml -l <host> -e claude_enabled=false

# Configure Claude API Key
./vibe.yml -l <host> -e "claude_env={ANTHROPIC_API_KEY: 'sk-ant-xxx'}"

# Use Microsoft extension marketplace
./vibe.yml -l <host> -e code_gallery=microsoft

# 1. Deploy infrastructure (INFRA module)
./infra.yml

# 2. Deploy PostgreSQL (PGSQL module)
./pgsql.yml

# 3. Deploy JuiceFS shared storage (optional, JUICE module)
./juice.yml

# 4. Deploy VIBE development environment
./vibe.yml

./deploy.yml  # Includes INFRA + PGSQL
./juice.yml   # JuiceFS (optional)
./vibe.yml    # VIBE

# First deployment
./vibe.yml -l <host>

# Re-run after config change (safe)
./vibe.yml -l <host>

# Execute on specified host only
./vibe.yml -l 10.10.10.10

# Execute on specified group only
./vibe.yml -l infra

./vibe.yml -l <host> --check

./vibe.yml -l <host> -v      # Verbose
./vibe.yml -l <host> -vv     # More verbose
./vibe.yml -l <host> -vvv    # Debug level

# Check service status
sudo systemctl status code-server

# Start service
sudo systemctl start code-server

# Stop service
sudo systemctl stop code-server

# Restart service
sudo systemctl restart code-server

# Enable at boot
sudo systemctl enable code-server

# Disable at boot
sudo systemctl disable code-server

# Check service status
sudo systemctl status jupyter

# Start service
sudo systemctl start jupyter

# Stop service
sudo systemctl stop jupyter

# Restart service
sudo systemctl restart jupyter

# Enable at boot
sudo systemctl enable jupyter

# Disable at boot
sudo systemctl disable jupyter

# Code-Server logs
journalctl -u code-server -f

# JupyterLab logs
journalctl -u jupyter -f

# View last 100 lines
journalctl -u code-server -n 100
journalctl -u jupyter -n 100

# Edit config file
sudo vi /data/code/code-server/config.yaml

# Modify password field
password: YourNewPassword

# Restart service
sudo systemctl restart code-server

# Modify code_password in pigsty.yml
# Then execute
./vibe.yml -l <host> -t code_config,code_launch

# Edit config file
sudo vi /data/jupyter/jupyter_config.py

# Modify c.ServerApp.token value
c.ServerApp.token = 'YourNewToken'

# Restart service
sudo systemctl restart jupyter

# Modify jupyter_password in pigsty.yml
# Then execute
./vibe.yml -l <host> -t jupyter_config,jupyter_launch

# Install single extension
code-server --install-extension ms-python.python

# Install from VSIX file
code-server --install-extension /path/to/extension.vsix

# List installed extensions
code-server --list-extensions

# Uninstall extension
code-server --uninstall-extension ms-python.python

# Open VSX (default)
code_gallery: openvsx

# Microsoft official marketplace
code_gallery: microsoft

./vibe.yml -l <host> -t code_config,code_launch

# Activate venv
source /data/venv/bin/activate

# Install extension
pip install jupyterlab-git
pip install jupyterlab-lsp

# Restart JupyterLab
sudo systemctl restart jupyter

# Activate venv
source /data/venv/bin/activate

# Install with pip
pip install numpy pandas matplotlib scikit-learn

# Use Tsinghua mirror (China)
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy pandas

# Install with uv (faster)
uv pip install numpy pandas matplotlib

# Temporary use
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple <package>

# Permanent config
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# Install ipykernel
pip install ipykernel

# Register new kernel
python -m ipykernel install --user --name myenv --display-name "Python (myenv)"

# List registered kernels
jupyter kernelspec list

# Remove kernel
jupyter kernelspec remove myenv

# Temporary
export ANTHROPIC_API_KEY=sk-ant-xxx-your-api-key

# Permanent (add to ~/.bashrc or ~/.zshrc)
echo 'export ANTHROPIC_API_KEY=sk-ant-xxx-your-api-key' >> ~/.bashrc
source ~/.bashrc

claude config set apiKey sk-ant-xxx-your-api-key

claude_env:
  ANTHROPIC_API_KEY: sk-ant-xxx-your-api-key

# View current config
cat ~/.claude.json
cat ~/.claude/settings.json

# View Claude version
claude --version

# Start Claude in current directory
claude

# Start in specified directory
claude /path/to/project

# Non-interactive mode
claude -p "Explain this code"

# Specify model
claude --model claude-sonnet-4-20250514

import psycopg2

# Connect to database
conn = psycopg2.connect(
    'postgres://dbuser_dba:[email protected]:5432/meta'
)
cursor = conn.cursor()

# Execute query
cursor.execute('SELECT version()')
print(cursor.fetchone())

# Close connection
cursor.close()
conn.close()

import pandas as pd
import psycopg2

conn = psycopg2.connect(
    'postgres://dbuser_dba:[email protected]:5432/meta'
)
df = pd.read_sql('SELECT * FROM pg_stat_activity', conn)
df.head()

# Using psql
psql postgres://dbuser_dba:[email protected]:5432/meta

# Using pgcli (if installed)
pgcli postgres://dbuser_dba:[email protected]:5432/meta

# Backup user data
tar -czvf code-backup.tar.gz /data/code

# Restore
tar -xzvf code-backup.tar.gz -C /
sudo systemctl restart code-server

# Backup config and notebooks
tar -czvf jupyter-backup.tar.gz /data/jupyter /fs/*.ipynb

# Restore
tar -xzvf jupyter-backup.tar.gz -C /
sudo systemctl restart jupyter

# View detailed error logs
journalctl -u code-server -xe
journalctl -u jupyter -xe

# Check port usage
ss -tlnp | grep 8443
ss -tlnp | grep 8888

# Check processes
ps aux | grep code-server
ps aux | grep jupyter

# Check Nginx status
sudo systemctl status nginx

# Check Nginx config
sudo nginx -t

# Check firewall
sudo firewall-cmd --list-all

# Check Python version in venv
/data/venv/bin/python --version

# Check JupyterLab version
/data/venv/bin/jupyter --version

# Rebuild venv
rm -rf /data/venv
python3 -m venv /data/venv
/data/venv/bin/pip install jupyterlab ipykernel

{
  "otelEndpointMetrics": "http://127.0.0.1:8428/opentelemetry/v1/metrics",
  "otelEndpointLogs": "http://127.0.0.1:9428/insert/opentelemetry/v1/logs",
  "otelResourceAttributes": {
    "ip": "10.10.10.10",
    "job": "claude"
  }
}

# Check Code-Server status
systemctl status code-server

# Check JupyterLab status
systemctl status jupyter

# View service logs
journalctl -u code-server -f
journalctl -u jupyter -f

# Check Code-Server port (8443)
ss -tlnp | grep 8443

# Check JupyterLab port (8888)
ss -tlnp | grep 8888

# Use curl to check services
curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:8443
curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:8888

#!/bin/bash
# vibe-health-check.sh

echo "=== VIBE Service Health Check ==="

# Code-Server
if systemctl is-active --quiet code-server; then
    echo "[OK] Code-Server: Running"
else
    echo "[ERROR] Code-Server: Not running"
fi

# JupyterLab
if systemctl is-active --quiet jupyter; then
    echo "[OK] JupyterLab: Running"
else
    echo "[ERROR] JupyterLab: Not running"
fi

# Port checks
if ss -tlnp | grep -q ":8443 "; then
    echo "[OK] Code-Server port 8443: Listening"
else
    echo "[ERROR] Code-Server port 8443: Not listening"
fi

if ss -tlnp | grep -q ":8888 "; then
    echo "[OK] JupyterLab port 8888: Listening"
else
    echo "[ERROR] JupyterLab port 8888: Not listening"
fi

# Check Code-Server
curl -s -o /dev/null -w "%{http_code}\n" \
    --connect-timeout 5 \
    http://127.0.0.1:8443/healthz

# Check JupyterLab
curl -s -o /dev/null -w "%{http_code}\n" \
    --connect-timeout 5 \
    http://127.0.0.1:8888/api/status

# Example: Code-Server down alert
- alert: CodeServerDown
  expr: up{job="code-server"} == 0
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "Code-Server service down"
    description: "Code-Server on {{ $labels.instance }} has been down for over 5 minutes"

# Example: JupyterLab down alert
- alert: JupyterLabDown
  expr: up{job="jupyter"} == 0
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: "JupyterLab service down"
    description: "JupyterLab on {{ $labels.instance }} has been down for over 5 minutes"

# View recent logs
journalctl -u code-server -n 100

# View specific time range
journalctl -u code-server --since "2024-01-01" --until "2024-01-02"

# Real-time follow
journalctl -u code-server -f

# Query via Grafana Explore panel
# Or use vlogs API
curl -G 'http://localhost:9428/select/logsql/query' \
    --data-urlencode 'query={job="claude"}'

# View Code-Server resource usage
systemctl status code-server
ps aux | grep code-server

# View JupyterLab resource usage
systemctl status jupyter
ps aux | grep jupyter

# View memory usage
free -h

# View disk usage
df -h /data
df -h /fs

# View JuiceFS status
juicefs status /fs

# View filesystem usage
df -h /fs

# View file stats
juicefs info /fs

# Increase file handle limit (already in systemd service)
# /etc/systemd/system/code-server.service
LimitNOFILE=65535

# /data/jupyter/jupyter_config.py

# Increase max buffer size
c.ServerApp.max_buffer_size = 1073741824  # 1GB

# Configure timeout
c.ServerApp.shutdown_no_activity_timeout = 0  # Disable auto-shutdown

# Download Pigsty
curl https://repo.pigsty.io/get | bash

# Use vibe config template
./configure -c vibe

# Modify passwords then deploy
vi pigsty.yml
./deploy.yml
./juice.yml   # Optional
./vibe.yml

# Check repo availability
yum repolist          # EL systems
apt update            # Debian/Ubuntu

# Refresh repo cache
./infra.yml -t repo

# Check venv
ls -la /data/venv/bin/python

# If not exists, create manually
python3 -m venv /data/venv

# Re-run playbook
./vibe.yml -l <host> -t jupyter

proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

infra_portal:
  code: { domain: code.pigsty, endpoint: "127.0.0.1:8443", websocket: true }
  jupyter: { domain: jupyter.pigsty, endpoint: "127.0.0.1:8888", websocket: true }

vi /data/code/code-server/config.yaml
# Modify password field
systemctl restart code-server

# Modify code_password in pigsty.yml
./vibe.yml -l <host> -t code_config,code_launch

vi /data/jupyter/jupyter_config.py
# Modify c.ServerApp.token
systemctl restart jupyter

# Modify jupyter_password in pigsty.yml
./vibe.yml -l <host> -t jupyter_config,jupyter_launch

# Code-Server password
grep password /data/code/code-server/config.yaml

# JupyterLab Token
grep token /data/jupyter/jupyter_config.py

# Check VictoriaMetrics
curl http://127.0.0.1:8428/api/v1/status/buildinfo

# Check VictoriaLogs
curl http://127.0.0.1:9428/select/logsql/stats_query

# Activate venv
source /data/venv/bin/activate

# Check JupyterLab version
jupyter --version

# Install extension
pip install jupyterlab-git

# Restart service
systemctl restart jupyter

# Activate venv
source /data/venv/bin/activate

# Install packages
pip install numpy pandas matplotlib

# Use Tsinghua mirror (China)
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy pandas

# Install ipykernel
pip install ipykernel

# Register kernel
python -m ipykernel install --user --name myenv --display-name "Python (myenv)"

# List kernels
jupyter kernelspec list

import psycopg2

conn = psycopg2.connect(
    'postgres://dbuser_dba:[email protected]:5432/meta'
)
cursor = conn.cursor()
cursor.execute('SELECT version()')
print(cursor.fetchone())
conn.close()

# Check disk usage
df -h

# Clean logs
journalctl --vacuum-time=7d

# Clean pip cache
pip cache purge

code_password: 'YourStrongPassword!'
jupyter_password: 'YourStrongToken!'