Yeaft — Interface Web Multi-Provider para Claude e IA
yeaft/claude-web-chat
Interface web hub-and-spoke para rodar Claude Code CLI em múltiplas máquinas
Ver no GitHubPlataforma de colaboração com IA que oferece uma interface web unificada para acessar Claude Code CLI, GitHub Copilot CLI e o próprio motor Yeaft. Suporta múltiplas máquinas via arquitetura hub-and-spoke com WebSocket, agentes distribuídos e frontend Vue.js com histórico persistido, criptografia e colaboração multi-função.
Instalação
npx convez-ai yeaft/claude-web-chat1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Acessar Claude Code CLI remotamente via navegador em múltiplas máquinas
- Colaboração multi-agente com suporte a @mention e parallel fan-out
- Gerenciamento centralizado de sessões com histórico persistido e memória cross-session
Veredito

Solução robusta e bem-documentada para quem precisa de acesso remoto e distribuído ao Claude CLI. Arquitetura completa (WebSocket, criptografia E2E, multi-provider) indica projeto maduro, mas requer familiaridade com Node.js e DevOps para deployment.
README
A tradução para o português deste README ainda está na fila.
Yeaft
English | 中文 | Documentation
Multi-provider AI collaboration platform — one web interface, three backends: Claude Code CLI · GitHub Copilot CLI · Yeaft's own multi-VP engine. Multi-machine management, end-to-end encryption, multi-role collaboration.
🌐 Try it now: cc.yeaft.com — open registration, no invite code required.

Features
Pick Your Backend
Yeaft is not bound to a single AI vendor. When starting a new session, choose:
| Backend | Best for |
|---|---|
| Claude Code | 1:1 chat with Claude Code CLI — full Claude toolset |
| Copilot | 1:1 chat via GitHub Copilot CLI (ACP protocol) — pick any Claude / GPT model |
| Yeaft Sessions | Multi-VP group collaboration, parallel fan-out, cross-session persistent memory |
Chat (Claude Code)
ChatGPT-style conversational interface with real-time tool tracking, session management, and file uploads.
- Real-time streaming of Claude responses
- Visual display of Read, Edit, Bash, and other tool executions
- Slash commands (
/model,/memory,/skills, etc.) with autocomplete /btwside questions — ask Claude a quick follow-up without interrupting the current task- Sub-agent panel — monitor and inspect nested agent tool calls in real time
- Session persistence with SQLite-backed history
- Session pinning — pin important conversations to the top of the sidebar
- Drag-and-drop file/image attachments
- Dark / light theme with one-click toggle
- Bilingual interface (English / 中文) with runtime language switching
- Mobile-responsive layout
Copilot CLI Backend
The same chat surface but powered by copilot --acp instead of claude. Speaks ACP (Agent Client Protocol); the agent translates every ACP event into the same claude_output envelope, so the rendering pipeline is shared.
- Pick any Claude / GPT model from Copilot's catalog
- Per-session permission dialog (allow once / always / deny)
- Session resume + history
- Uses your existing GitHub Copilot OAuth — no separate API key
Yeaft Sessions
Multi-VP (Virtual Person) parallel collaboration, powered by Yeaft's own engine (no CLI subprocess required).
- Create a group, drop multiple VPs (independently configured persona / model / tools)
@mentiondecides which VPs handle each message — parallel fan-out- Cross-session persistent memory (H2-AMS) — VPs remember what you said last session
- Multi-provider LLM router (Anthropic, OpenAI Responses, GitHub Copilot, any OpenAI-compatible proxy)
- 40+ built-in tools (file, bash, web, agent orchestration)
- VP→VP explicit handoff via
route_forwardtool

Split Screen
Open multiple conversations side by side — up to 3 panels at once.
- Split any session into a new panel from the sidebar
- Each panel is a fully independent conversation view
- Active-panel focus indicator for keyboard and sidebar interaction
- Panels can be closed individually; closing all returns to single-panel mode
Expert Panel
AI expert teams that assist your conversations — select a team (e.g. Writing, Trading) and get multi-perspective advice in a side panel.
- Multiple pre-built expert teams with specialized roles
- Expert responses appear in a collapsible side panel
- Team selection via chip-style tabs
- Works alongside normal chat without interrupting the flow
Crew (Multi-Agent Collaboration)
Multi-role AI team collaboration with PM, Developer, Reviewer, and Tester roles working together on features.
- Automated task routing between roles via ROUTE protocol
- Feature progress tracking panel with real-time status (streaming pulse animation)
- Role-based message grouping with decision-maker messages in main stream
- Parallel multi-agent execution across multiple worktrees
- Feature completion detection with auto-reactivation on new activity
- AskUserQuestion interactive cards — agents can prompt the user for decisions mid-task
- Typing indicator with event-driven health monitoring (agent offline / session lost / compacting)


Admin Dashboard
Usage statistics and system monitoring for administrators.
- User activity metrics with time-based filtering (today/week/month)
- Per-user usage breakdown (messages, sessions, requests, traffic)
- Connected agent status and latency monitoring
- Mobile-responsive card layout

Workbench
Integrated development environment with terminal, Git operations, file browser, and port proxy.
- Full terminal emulator (xterm.js) with PTY support
- Git status, diff viewer, and branch management
- File browser with CodeMirror editor
- Port proxy: forward agent local ports to your browser

Prerequisites
- Server: Node.js >= 22.5, Docker (recommended for production)
- Agent: Node.js >= 22.5, plus at least one of:
- Claude Code CLI — required for Claude Chat mode
- GitHub Copilot CLI — required for Copilot mode (optional)
- Yeaft engine is bundled in the npm package; no extra CLI required for Yeaft Sessions
- Web Client: Modern browser (Chrome, Firefox, Safari, Edge)
Configure Yeaft LLM providers from the agent CLI
Installed agents expose local LLM configuration through yeaft-agent llm. These commands write only this machine's ~/.yeaft/config.json; they do not update any server-global or UI-global provider list.
yeaft-agent llm setup
yeaft-agent llm use github-copilot --model claude-sonnet-4.5 --fast gpt-4.1
GitHub Copilot uses the local device token / gh auth credential provider, refreshes the live model catalog from the Copilot API, and never writes a token to config. For custom OpenAI-compatible endpoints:
OPENAI_KEY=sk-... yeaft-agent llm use openai-compatible --name openai --base-url https://api.openai.com/v1 --api-key-env OPENAI_KEY --model gpt-5
Advanced manual setup is still available:
OPENAI_KEY=sk-... yeaft-agent llm add-provider --name openai --base-url https://api.openai.com/v1 --models gpt-5,gpt-4.1 --api-key-env OPENAI_KEY --protocol openai-responses --set-primary gpt-5
yeaft-agent llm show
yeaft-agent llm set-model --primary openai/gpt-5 --fast openai/gpt-4.1
yeaft-agent llm remove-provider --name openai
Run yeaft-agent llm --help for the full command list and examples. The Yeaft session header's LLM config button edits the same local agent config.
Architecture
┌──────────────────────────────────────────┐
│ Server (@yeaft/webchat-server) │
│ Express + WebSocket Hub │
│ - Agent/web client management │
│ - Multi-layer authentication │
│ - End-to-end encryption (TweetNaCl) │
│ - Message routing & queue │
│ - SQLite session persistence │
└──────────────────┬───────────────────────┘
│ Encrypted WebSocket
┌──────────┴──────────┐
│ │
┌───────▼───────┐ ┌──────▼──────────┐
│ Agent │ │ Web Client │
│ @yeaft/ │ │ (web/) │
│ webchat-agent │ │ │
│ │ │ - Vue 3 + Pinia │
│ - Manages │ │ - Split-screen │
│ Claude CLI │ │ multi-panel │
│ - Crew multi- │ │ - E2E encrypted │
│ agent coord │ │ - Dark / light │
│ - Terminal │ │ - en / zh-CN │
│ - Git / Files │ │ - File upload │
└───────────────┘ └─────────────────┘
Quick Start
Option A: npm (Agent only)
# Install the agent globally
npm install -g @yeaft/webchat-agent
# Connect to a server
yeaft-agent --server wss://your-server.com --name my-worker --secret your-secret
# Upgrade to latest
yeaft-agent upgrade
Option B: Full development setup
git clone https://github.com/yeaft/claude-web-chat.git
cd claude-web-chat
# Install all dependencies
npm install
# Start server + agent in dev mode (no auth)
npm run dev
Then open http://localhost:3456 in your browser.
Production Deployment
Server (Docker)
cd server
cp .env.example .env
# Edit .env — set JWT_SECRET, AGENT_SECRET
# docker-compose.yaml
services:
webchat:
build:
context: .
dockerfile: Dockerfile
expose:
- "3456"
env_file:
- server/.env
environment:
- NODE_ENV=production
- SKIP_AUTH=false
volumes:
- ./data:/app/data
restart: unless-stopped
# Start the server (data/ and SQLite DB are auto-created on first run)
docker compose up -d --build webchat
# Create the first admin user
docker compose exec webchat node server/create-user.js admin your-password admin@example.com
Additional users can register directly from the login page (open registration, no invite code required).

Agent
Via npm (recommended):
npm install -g @yeaft/webchat-agent
# Run once (foreground)
yeaft-agent --server wss://your-server.com --name worker-1 --secret your-secret
# Or install as system service (auto-start on boot, auto-restart on crash)
yeaft-agent install --server wss://your-server.com --name worker-1 --secret your-secret
# Manage installed service
yeaft-agent status # check if running
yeaft-agent logs # view logs (follow mode)
yeaft-agent restart # restart
yeaft-agent uninstall # remove service
From source (for development or without npm global install):
cd agent
cp .env.example .env
# Edit .env — set SERVER_URL, AGENT_NAME, AGENT_SECRET, WORK_DIR
# Run in foreground
node index.js
# Or install as system service (reads config from .env)
node cli.js install
# Manage installed service
node cli.js status
node cli.js logs
node cli.js uninstall
You can find the Agent secret in Settings > Security within the web interface:

When no Agent is connected, the welcome page guides you to Settings:

Agent CLI
yeaft-agent [options] Run agent in foreground
yeaft-agent install [options] Install as system service (Linux/macOS/Windows)
yeaft-agent uninstall Remove system service
yeaft-agent start Start installed service
yeaft-agent stop Stop installed service
yeaft-agent restart Restart installed service
yeaft-agent status Show service status
yeaft-agent logs View service logs
yeaft-agent upgrade Upgrade to latest version
yeaft-agent --version Show version
Options:
--server <url> WebSocket server URL
--name <name> Agent display name
--secret <secret> Authentication secret
--work-dir <dir> Default working directory
--auto-upgrade Check for updates on startup
Environment variables (alternative to flags):
SERVER_URL, AGENT_NAME, AGENT_SECRET, WORK_DIR
Security
Authentication
- Username + Password (bcrypt hashed)
- TOTP 2FA (optional, Google/Microsoft Authenticator)
- Email verification (optional, requires SMTP)
Production Requirements
The server refuses to start in production mode if:
JWT_SECRETis left at default
If no users are configured, the server starts with a warning — create the first user via docker compose exec.
Agent Authentication
- Agents authenticate via WebSocket message (secret never in URL)
- Per-user agent secret: Agent bound to a specific user (only that user can see it)
- Global AGENT_SECRET: Env var fallback, only visible to admin users
- Each connection gets a unique session key for encryption
Roles & Permissions
All registered users are Pro by default. The first user created via CLI is Admin.
| Feature | pro | admin |
|---|---|---|
| Chat | yes | yes |
| Expert Panel | yes | yes |
| Own agents (per-user secret) | yes | yes |
| Global agents (AGENT_SECRET) | - | yes |
| Workbench (Terminal, Git, Files) | yes | yes |
| Port Proxy | yes | yes |
| Admin Dashboard | - | yes |
| Manage invitations | - | yes |
Project Structure
claude-web-chat/
├── server/ # Central WebSocket hub (Express + ws)
│ ├── index.js # Entry point
│ ├── handlers/ # Message handlers (agent↔client routing)
│ ├── api.js # REST endpoints (auth, sessions, users)
│ ├── proxy.js # Port proxy forwarding
│ ├── database.js # SQLite storage
│ └── auth.js # JWT + TOTP + email verification
├── agent/ # Worker machine agent
│ ├── cli.js # CLI entry point (yeaft-agent command)
│ ├── index.js # Agent startup & capability detection
│ ├── connection/ # WebSocket connection, auth & message routing
│ ├── providers/ # ChatProvider abstraction
│ │ ├── base.js # ChatProvider interface + capabilities
│ │ ├── claude-code.js # Claude CLI driver
│ │ ├── copilot.js # GitHub Copilot CLI driver (ACP)
│ │ └── acp-client.js# ACP JSON-RPC client
│ ├── yeaft/ # Yeaft's own AI engine (no external CLI)
│ │ ├── engine.js # Main query loop
│ │ ├── memory/ # H2-AMS memory subsystem
│ │ ├── llm/ # Multi-provider LLM adapters
│ │ ├── groups/ # Group Mode orchestration
│ │ └── tools/ # 40+ built-in tools
│ ├── claude.js # Legacy Claude CLI process management
│ ├── conversation.js # Chat session lifecycle & slash commands
│ ├── crew/ # Multi-agent Crew coordination (13 modules)
│ ├── sdk/ # Claude CLI stream-json SDK
│ ├── terminal.js # PTY terminal (node-pty)
│ └── workbench/ # Git + file operations
├── web/ # Vue 3 frontend
│ ├── app.js # Vue app entry
│ ├── build.js # Production build (esbuild)
│ ├── components/ # Vue components (25 top-level + crew/ sub-dir)
│ ├── stores/ # Pinia stores + helpers
│ ├── styles/ # CSS (23 stylesheets, dark/light theme)
│ ├── i18n/ # Translations (en, zh-CN)
│ └── vendor/ # Third-party libs (local, no CDN)
├── test/ # Vitest unit & integration tests (68 files, 2700+ tests)
├── e2e/ # Playwright end-to-end tests
├── docs/ # VitePress documentation site
├── Dockerfile # Multi-stage production build
└── LICENSE # MIT
Tech Stack
- Server: Node.js, Express, ws, node:sqlite, compression
- Frontend: Vue 3, Pinia, xterm.js, CodeMirror 5, marked, highlight.js
- Build: esbuild (frontend bundling)
- Testing: Vitest (2,700+ unit/integration tests), Playwright (E2E)
- Encryption: TweetNaCl (XSalsa20-Poly1305)
- Auth: JWT, bcrypt, speakeasy (TOTP), nodemailer
- Docs: VitePress
- Deploy: Docker multi-stage build
CI/CD
GitHub Actions workflows included:
- CI (
ci.yml): Tests on Node 24 + frontend build (manual trigger viaworkflow_dispatch) - Release (
release.yml): On tagrelease-*— runs tests, publishes@yeaft/webchat-agentto npm, builds Docker image to GHCR, creates GitHub Release
Publishing a release
# Tag and push (use release- prefix)
git tag release-v0.1.294
git push origin release-v0.1.294
# GitHub Actions handles the rest
FAQ
See README.zh-CN.md for detailed troubleshooting (in Chinese).
Contributing
See CONTRIBUTING.md for development setup and guidelines.
Disclaimer
This is an independent, community-driven open-source project. It is not affiliated with, endorsed by, or officially connected to Anthropic, PBC in any way.
"Claude" is a trademark of Anthropic. This project provides a web interface for the Claude Code CLI and does not modify or redistribute any Anthropic software.
Use at your own risk. The authors assume no liability for any issues arising from the use of this software.