# Codeg
[](https://github.com/xintaofei/codeg/releases)
[](../../LICENSE)
[](https://tauri.app/)
[](https://nextjs.org/)
[](../../Dockerfile)
English |
简体中文 |
繁體中文 |
日本語 |
한국어 |
Español |
Deutsch |
Français |
Português |
العربية
Codeg (Code Generation) ist ein unternehmenstauglicher Multi-Agent-Workspace
für die Programmierung.
Es vereint lokale KI-Coding-Agenten (Claude Code, Codex CLI, OpenCode,
Gemini CLI, OpenClaw usw.) in einer Desktop-App, einem Standalone-Server oder
Docker-Container — Remote-Entwicklung von jedem Browser aus — mit Konversationsaggregation,
paralleler `git worktree`-Entwicklung, MCP/Skills-Verwaltung, Chat-Kanal-Integration
(Telegram, Lark, iLink usw.) und integrierten Git/Datei/Terminal-Workflows.
## Kommunikationsfluss
## Hauptoberfläche
## Einstellungen
| Agenten | MCP | Skills | Versionskontrolle | Webdienst |
| :---: | :---: | :---: | :---: | :---: |
|   |   |   |   |   |
## Highlights
- Einheitlicher Multi-Agent-Workspace im selben Projekt
- Lokale Konversationserfassung mit strukturierter Darstellung
- Parallele Entwicklung mit integrierten `git worktree`-Abläufen
- **Projekt-Starter** — neue Projekte visuell erstellen mit Live-Vorschau
- **Chat-Kanäle** — Telegram, Lark (Feishu), iLink (Weixin) und mehr mit Ihren Coding-Agenten verbinden für vollständige Sitzungsinteraktion und Remote-Aufgabensteuerung
- MCP-Verwaltung (lokaler Scan + Registry-Suche/Installation)
- Skills-Verwaltung (global und projektbezogen)
- Git-Remote-Kontoverwaltung (GitHub und andere Git-Server)
- Webdienst-Modus — Zugriff auf Codeg über jeden Browser für Remote-Arbeit
- Standalone-Server-Bereitstellung — codeg-server auf jedem Linux/macOS-Server ausführen, Zugriff über den Browser
- **Docker-Unterstützung** — `docker compose up` oder `docker run`, mit benutzerdefiniertem Token/Port, Datenpersistenz und Projektverzeichnis-Mounts
- Integrierter Engineering-Kreislauf (Dateibaum, Diff, Git-Änderungen, Commit, Terminal)
## Projekt-Starter
Erstellen Sie neue Projekte visuell mit einer geteilten Oberfläche: links konfigurieren, rechts in Echtzeit Vorschau anzeigen.
### Funktionen
- **Visuelle Konfiguration** — Stil, Farbthema, Icon-Bibliothek, Schrift, Rahmenradius und mehr über Dropdowns auswählen; die Vorschau aktualisiert sich sofort
- **Live-Vorschau** — das gewählte Look & Feel wird in Echtzeit gerendert, bevor etwas erstellt wird
- **Ein-Klick-Erstellung** — klicken Sie auf „Projekt erstellen" und der Launcher führt `shadcn init` mit Ihrem Preset, Framework-Template (Next.js / Vite / React Router / Astro / Laravel) und Paketmanager (pnpm / npm / yarn / bun) aus
- **Paketmanager-Erkennung** — prüft automatisch, welche Paketmanager installiert sind und zeigt ihre Versionen an
- **Nahtlose Integration** — das neu erstellte Projekt wird sofort im Codeg-Workspace geöffnet
Unterstützt derzeit **shadcn/ui**-Projekt-Scaffolding, mit einem Tab-basierten Design für zukünftige Projekttypen.
## Chat-Kanäle
Verbinden Sie Ihre bevorzugten Messaging-Apps — Telegram, Lark (Feishu), iLink (Weixin) und mehr — mit Ihren KI-Coding-Agenten. Erstellen Sie Aufgaben, senden Sie Folgenachrichten, genehmigen Sie Berechtigungen, setzen Sie Sitzungen fort und überwachen Sie die Aktivität direkt aus dem Chat — empfangen Sie Echtzeit-Antworten der Agenten mit Tool-Call-Details, Berechtigungsanfragen und Abschlusszusammenfassungen, ohne einen Browser zu öffnen.
### Unterstützte Kanäle
| Kanal | Protokoll | Status |
| --- | --- | --- |
| Telegram | Bot API (HTTP Long-Polling) | Integriert |
| Lark (Feishu) | WebSocket + REST API | Integriert |
| iLink (Weixin) | WebSocket + REST API | Integriert |
> Weitere Kanäle (Discord, Slack, DingTalk usw.) sind für zukünftige Releases geplant.
### Hauptfunktionen
- **Sitzungs-Interaktion** — vollständige Agenten-Sitzungen ausführen: `/folder` Projekt wählen, `/agent` Agent auswählen, `/task ` Aufgabe starten, Folgenachrichten als Klartext senden. `/resume` vorherige Sitzung fortsetzen, `/cancel` abbrechen, `/sessions` aktive Sitzungen auflisten
- **Berechtigungssteuerung** — Agenten fordern Tool-Ausführungsberechtigungen im Chat an; `/approve` (oder `/approve always` für automatische Genehmigung) und `/deny`
- **Ereignisbenachrichtigungen** — Agenten-Rundenvervollständigungen, Tool-Calls und Fehler werden in Echtzeit mit Rich-Formatierung gepusht
- **Abfragebefehle** — `/search `, `/today`, `/status`, `/help` für schnelle Abfragen; konfigurierbarer Befehlspräfix
- **Tagesberichte** — automatisierte tägliche Zusammenfassung zu einer geplanten Zeit, einschließlich Konversationszählung, Aufschlüsselung nach Agent-Typ und Projektaktivität
- **Mehrsprachig** — Nachrichtenvorlagen in 10 Sprachen (Englisch, vereinfachtes/traditionelles Chinesisch, Japanisch, Koreanisch, Spanisch, Deutsch, Französisch, Portugiesisch, Arabisch)
- **Sichere Anmeldedaten** — Token werden im OS-Schlüsselbund gespeichert, nie in Konfigurationsdateien oder Logs exponiert
- **Rich-Nachrichten** — Markdown-Formatierung für Telegram, kartenbasiertes Layout für Lark; Klartext-Fallback für alle Plattformen
### Einrichtung
1. Erstellen Sie einen Kanal unter **Einstellungen → Chat-Kanäle** (wählen Sie Telegram, Lark oder iLink)
2. Geben Sie Ihren Bot-Token (Telegram), App-Anmeldedaten (Lark) ein oder scannen Sie den QR-Code zum Anmelden (iLink) — sicher im OS-Schlüsselbund gespeichert
3. Konfigurieren Sie Ereignisfilter und optionalen Tagesberichtsplan
4. Verbinden — Nachrichten beginnen zu fließen, sobald Agenten Ereignisse aussenden
## Unterstützte Agenten
| Agent | Umgebungsvariablen-Pfad | macOS / Linux Standard | Windows Standard |
| --- | --- | --- | --- |
| Claude Code | `$CLAUDE_CONFIG_DIR/projects` | `~/.claude/projects` | `%USERPROFILE%\\.claude\\projects` |
| Codex CLI | `$CODEX_HOME/sessions` | `~/.codex/sessions` | `%USERPROFILE%\\.codex\\sessions` |
| OpenCode | `$XDG_DATA_HOME/opencode/opencode.db` | `~/.local/share/opencode/opencode.db` | `%USERPROFILE%\\.local\\share\\opencode\\opencode.db` |
| Gemini CLI | `$GEMINI_CLI_HOME/.gemini` | `~/.gemini` | `%USERPROFILE%\\.gemini` |
| OpenClaw | — | `~/.openclaw/agents` | `%USERPROFILE%\\.openclaw\\agents` |
| Cline | `$CLINE_DIR` | `~/.cline/data/tasks` | `%USERPROFILE%\\.cline\\data\\tasks` |
> Hinweis: Umgebungsvariablen haben Vorrang vor Fallback-Pfaden.
## Schnellstart
### Voraussetzungen
- Node.js `>=22` (empfohlen)
- pnpm `>=10`
- Rust stable (2021 edition)
- Tauri-2-Build-Abhängigkeiten (nur Desktop-Modus)
Linux-Beispiel (Debian/Ubuntu):
```bash
sudo apt-get update
sudo apt-get install -y \
libwebkit2gtk-4.1-dev \
libayatana-appindicator3-dev \
librsvg2-dev \
patchelf
```
### Entwicklung
```bash
pnpm install
# Frontend-Statikexport nach out/
pnpm build
# Vollständige Desktop-App (Tauri + Next.js)
pnpm tauri dev
# Nur Frontend
pnpm dev
# Desktop-Build
pnpm tauri build
# Standalone-Server (kein Tauri/GUI erforderlich)
pnpm server:dev
# Server-Release-Binary erstellen
pnpm server:build
# Lint
pnpm eslint .
# Rust-Prüfungen (in src-tauri/ ausführen)
cargo check
cargo clippy
cargo build
```
### Server-Bereitstellung
Codeg kann als eigenständiger Webserver ohne Desktop-Umgebung betrieben werden.
#### Option 1: Ein-Zeilen-Installation (Linux / macOS)
```bash
curl -fsSL https://raw.githubusercontent.com/xintaofei/codeg/main/install.sh | bash
```
Eine bestimmte Version oder in ein benutzerdefiniertes Verzeichnis installieren:
```bash
curl -fsSL https://raw.githubusercontent.com/xintaofei/codeg/main/install.sh | bash -s -- --version v0.5.2 --dir ~/.local/bin
```
Dann ausführen:
```bash
codeg-server
```
#### Option 2: Ein-Zeilen-Installation (Windows PowerShell)
```powershell
irm https://raw.githubusercontent.com/xintaofei/codeg/main/install.ps1 | iex
```
Oder eine bestimmte Version installieren:
```powershell
.\install.ps1 -Version v0.5.2
```
#### Option 3: Von GitHub Releases herunterladen
Vorkompilierte Binärdateien (mit gebündelten Web-Assets) sind auf der [Releases](https://github.com/xintaofei/codeg/releases)-Seite verfügbar:
| Plattform | Datei |
| --- | --- |
| Linux x64 | `codeg-server-linux-x64.tar.gz` |
| Linux arm64 | `codeg-server-linux-arm64.tar.gz` |
| macOS x64 | `codeg-server-darwin-x64.tar.gz` |
| macOS arm64 | `codeg-server-darwin-arm64.tar.gz` |
| Windows x64 | `codeg-server-windows-x64.zip` |
```bash
# Beispiel: Herunterladen, Entpacken und Ausführen
tar xzf codeg-server-linux-x64.tar.gz
cd codeg-server-linux-x64
CODEG_STATIC_DIR=./web ./codeg-server
```
#### Option 4: Docker
```bash
# Mit Docker Compose (empfohlen)
docker compose up -d
# Oder direkt mit Docker ausführen
docker run -d -p 3080:3080 -v codeg-data:/data ghcr.io/xintaofei/codeg:latest
# Mit benutzerdefiniertem Token und Projektverzeichnis-Mount
docker run -d -p 3080:3080 \
-v codeg-data:/data \
-v /path/to/projects:/projects \
-e CODEG_TOKEN=your-secret-token \
ghcr.io/xintaofei/codeg:latest
```
Das Docker-Image verwendet einen Multi-Stage-Build (Node.js + Rust → schlanke Debian-Laufzeitumgebung) und enthält `git` und `ssh` für Repository-Operationen. Daten werden im `/data`-Volume persistent gespeichert. Optional können Projektverzeichnisse gemountet werden, um aus dem Container auf lokale Repositories zuzugreifen.
#### Option 5: Aus Quellcode kompilieren
```bash
pnpm install && pnpm build # Frontend kompilieren
cd src-tauri
cargo build --release --bin codeg-server --no-default-features
CODEG_STATIC_DIR=../out ./target/release/codeg-server
```
#### Konfiguration
Umgebungsvariablen:
| Variable | Standardwert | Beschreibung |
| --- | --- | --- |
| `CODEG_PORT` | `3080` | HTTP-Port |
| `CODEG_HOST` | `0.0.0.0` | Bind-Adresse |
| `CODEG_TOKEN` | *(zufällig)* | Authentifizierungstoken (wird beim Start auf stderr ausgegeben) |
| `CODEG_DATA_DIR` | `~/.local/share/codeg` | SQLite-Datenbankverzeichnis |
| `CODEG_STATIC_DIR` | `./web` oder `./out` | Next.js-Statikexport-Verzeichnis |
## Architektur
```text
Next.js 16 (Static Export) + React 19
|
| invoke() (desktop) / fetch() + WebSocket (web)
v
┌─────────────────────────┐
│ Transport Abstraction │
│ (Tauri IPC or HTTP/WS) │
└─────────────────────────┘
|
v
┌─── Tauri Desktop ───┐ ┌─── codeg-server ───┐
│ Tauri 2 Commands │ │ Axum HTTP + WS │
│ (window management) │ │ (standalone mode) │
└──────────┬───────────┘ └──────────┬──────────┘
└──────────┬───────────────┘
v
Shared Rust Core
|- AppState
|- ACP Manager
|- Parsers (conversation ingestion)
|- Chat Channels
|- Git / File Tree / Terminal
|- MCP marketplace + config
|- SeaORM + SQLite
|
┌───────┼───────┐
v v v
Local Filesystem Git Chat Channels
/ Git Repos Repos (Telegram, Lark, iLink)
```
## Einschränkungen
- Frontend verwendet statischen Export (`output: "export"`)
- Keine dynamischen Next.js-Routen (`[param]`); stattdessen Query-Parameter verwenden
- Tauri-Befehlsparameter: `camelCase` im Frontend, `snake_case` in Rust
- TypeScript im strikten Modus
## Datenschutz und Sicherheit
- Standardmäßig lokal für Analyse, Speicherung und Projektoperationen
- Netzwerkzugriff erfolgt nur bei benutzergesteuerten Aktionen
- Systemproxy-Unterstützung für Unternehmensumgebungen
- Der Webdienst-Modus verwendet tokenbasierte Authentifizierung
## Lizenz
Apache-2.0. Siehe `LICENSE`.