# LXC 171 - Claude Agent (Development Environment)

**Director:** `proxmox/lxc171-claude-agent/`
**VMID:** 171
**IP:** 10.0.20.171 (intern) | 100.95.55.51 (Tailscale)
**Host Proxmox:** pveelite (10.0.20.202)
**Rol:** Mediu de dezvoltare izolat pentru Claude Code

---

## Scripturi Disponibile

| Script | Descriere |
|--------|-----------|
| `scripts/start-agent.sh` | Pornește/atașează sesiune tmux "agent" |
| `scripts/work.sh` | Meniu interactiv pentru workflow complet |
| `scripts/new-task.sh` | Creează branch nou pentru task |
| `scripts/finish-task.sh` | Finalizează task (commit + push) |

---

## Informații Container

| Parametru | Valoare |
|-----------|---------|
| VMID | 171 |
| Hostname | claude-agent |
| IP intern | 10.0.20.171 |
| IP Tailscale | 100.95.55.51 |
| Host Proxmox | pveelite (10.0.20.202) |
| User | claude |
| Storage | local-zfs (32GB) |
| RAM | 4GB |
| CPU | 2 cores |

## Componente Instalate

- Ubuntu 24.04 LTS
- Node.js v20.x (via nvm)
- Claude Code
- tmux
- Git (configurat pentru Gitea)
- Tailscale

## Conectare

### De pe calculator (rețea internă)
```bash
ssh claude@10.0.20.171
```

### De pe telefon/exterior (Tailscale)
```bash
ssh claude@100.95.55.51
```

### VS Code Remote SSH
Config în `~/.ssh/config`:
```
Host claude-agent
    HostName 10.0.20.171
    User claude
```

## Scripturi Workflow

### start-agent.sh
Pornește sau se atașează la sesiunea tmux "agent".

```bash
~/start-agent.sh
```

### work.sh (recomandat)
Meniu interactiv pentru workflow complet:
- Listează proiectele disponibile în /workspace
- Permite crearea de branch-uri noi
- Continuarea pe branch-uri existente
- Finalizare task (commit + push)
- Vizualizare branch-uri

```bash
~/work.sh
```

### new-task.sh
Creează branch nou pentru un task (hardcodat pentru romfastsql).

```bash
~/new-task.sh fix/nume-bug
```

### finish-task.sh
Finalizează task-ul curent (commit + push).

```bash
~/finish-task.sh
```

## Workflow Complet

### De pe telefon (JuiceSSH + Tailscale)

1. Conectează-te la `100.95.55.51` cu user `claude`
2. Rulează:
```bash
~/start-agent.sh    # pornește tmux
~/work.sh           # meniu interactiv
```
3. Alege proiectul
4. Alege acțiunea (task nou / continuă / finalizează)
5. Lucrează cu Claude Code
6. Când termini: `~/work.sh` → opțiunea 3 (finalizează)

### De pe calculator (VS Code)

1. VS Code → Remote SSH → `claude-agent`
2. Open Folder → `/workspace/<proiect>`
3. Terminal → `source ~/.nvm/nvm.sh && claude`

## Structura Directoare pe LXC

```
/home/claude/
├── .ssh/
│   ├── authorized_keys      # Chei SSH pentru acces
│   ├── gitea_ed25519        # Cheie pentru Gitea
│   └── config               # Config SSH pentru Gitea
├── .nvm/                    # Node Version Manager
├── .claude/
│   └── settings.json        # Permisiuni Claude Code
├── .tmux.conf               # Configurare tmux
├── start-agent.sh -> /workspace/start-agent.sh
└── work.sh -> /workspace/work.sh

/workspace/
├── start-agent.sh           # Script pornire tmux
├── work.sh                  # Script workflow interactiv
├── new-task.sh              # Script creare branch
├── finish-task.sh           # Script finalizare task
├── CLAUDE.md                # Info agent
├── SETUP-COMPLETE.md        # Documentație setup
├── romfastsql/              # Proiect clonat
└── test/                    # Alte proiecte
```

## Comenzi tmux Utile

| Comandă | Acțiune |
|---------|---------|
| `Ctrl+A, d` | Detașare din sesiune |
| `Ctrl+A, c` | Fereastră nouă |
| `Ctrl+A, n` | Fereastră următoare |
| `Ctrl+A, p` | Fereastră anterioară |
| `Ctrl+A, [` | Mod scroll (q pentru ieșire) |
| `tmux attach -t agent` | Reatașare la sesiune |
| `tmux ls` | Listare sesiuni |

## Git / Gitea

### Clonare proiect nou
```bash
cd /workspace
git clone git@gitea.romfast.ro:romfast/<nume-repo>.git
```

### Workflow branch-uri
```bash
git checkout main
git pull
git checkout -b feature/nume-feature
# ... lucrezi ...
git add .
git commit -m "descriere"
git push -u origin feature/nume-feature
# Creează Pull Request în Gitea
```

## Troubleshooting

### Claude Code nu pornește
```bash
source ~/.nvm/nvm.sh
which claude
claude --version
```

### tmux nu găsește sesiunea
```bash
tmux ls
tmux new -s agent -c /workspace
```

### Git clone eșuează
```bash
# Testează conexiunea SSH la Gitea
ssh -T git@gitea.romfast.ro
```

### Tailscale nu funcționează
```bash
sudo systemctl status tailscaled
sudo tailscale status
tailscale ip
```

## Instalare Claude Code pe LXC nou (de la zero)

### 1. Creare LXC în Proxmox
```bash
# Pe Proxmox host (ex: pveelite)
pct create <VMID> local:vztmpl/ubuntu-24.04-standard_24.04-2_amd64.tar.zst \
  --hostname claude-agent \
  --memory 4096 \
  --cores 2 \
  --rootfs local-zfs:32 \
  --net0 name=eth0,bridge=vmbr0,ip=dhcp \
  --features nesting=1 \
  --unprivileged 1

pct start <VMID>
pct enter <VMID>
```

### 2. Setup sistem (ca root în LXC)
```bash
# Update și pachete de bază
apt update && apt upgrade -y
apt install -y curl git tmux sudo

# Creare user claude
useradd -m -s /bin/bash claude
echo "claude ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/claude
passwd claude  # setează parola

# Creare /workspace
mkdir -p /workspace
chown claude:claude /workspace
```

### 3. Setup user claude
```bash
su - claude

# Instalare nvm + Node.js
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
source ~/.bashrc
nvm install 20
nvm use 20
nvm alias default 20

# Instalare Claude Code
npm install -g @anthropic-ai/claude-code

# Verificare
claude --version
```

### 4. Configurare Claude Code
```bash
mkdir -p ~/.claude
cat > ~/.claude/settings.json << 'EOF'
{
  "permissions": {
    "allow": [
      "Bash(git *)",
      "Bash(npm *)",
      "Bash(node *)",
      "Read",
      "Write",
      "Edit"
    ],
    "deny": []
  }
}
EOF
```

### 5. Configurare tmux
```bash
cat > ~/.tmux.conf << 'EOF'
set -g prefix C-a
unbind C-b
bind C-a send-prefix
set -g mouse on
set -g history-limit 50000
set -g default-terminal "screen-256color"
EOF
```

### 6. Configurare Git + SSH pentru Gitea
```bash
# Generare cheie SSH
ssh-keygen -t ed25519 -f ~/.ssh/gitea_ed25519 -N ""

# Config SSH
cat > ~/.ssh/config << 'EOF'
Host gitea.romfast.ro
    HostName gitea.romfast.ro
    User git
    IdentityFile ~/.ssh/gitea_ed25519
    IdentitiesOnly yes
EOF
chmod 600 ~/.ssh/config

# Afișează cheia publică (adaug-o în Gitea → Settings → SSH Keys)
cat ~/.ssh/gitea_ed25519.pub

# Config Git
git config --global user.name "Claude Agent"
git config --global user.email "claude@romfast.ro"
git config --global init.defaultBranch main
```

### 7. Instalare scripturi workflow
```bash
cd /workspace

# Copiază scripturile din acest repo (de pe mașina locală)
# SAU creează-le manual conform secțiunii "Scripturi Disponibile"

# Creare symlink-uri
ln -s /workspace/start-agent.sh ~/start-agent.sh
ln -s /workspace/work.sh ~/work.sh

chmod +x /workspace/*.sh
```

### 8. (Opțional) Instalare Tailscale
```bash
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
# Autentifică-te cu contul Tailscale
tailscale ip  # notează IP-ul
```

### 9. Clonare proiecte
```bash
cd /workspace
git clone git@gitea.romfast.ro:romfast/romfastsql.git
# alte proiecte...
```

### 10. Test final
```bash
~/start-agent.sh
# În tmux:
source ~/.nvm/nvm.sh
claude --version
~/work.sh
```

### Copiere rapidă scripturi (dacă ai alt LXC configurat)
```bash
# De pe mașina locală
scp proxmox/lxc171-claude-agent/scripts/*.sh claude@<ip>:/workspace/
ssh claude@<ip> "chmod +x /workspace/*.sh && ln -sf /workspace/start-agent.sh ~/start-agent.sh && ln -sf /workspace/work.sh ~/work.sh"
```

---

## Legături Utile

- **Proxmox Index:** `../README.md`
- **Gitea:** https://gitea.romfast.ro

---

**Data setup:** 2025-12-31
**Ultima actualizare:** 2026-01-27