---
title: "Das Chatcode-Gateway"
seoTitle: "Chatcode-Gateway: Installation, Vertrauen & Funktionsweise"
navTitle: "Gateway"
description: "Was das Chatcode-Gateway ist, wo es läuft (Linux vs. macOS), wie es kommuniziert, welche Kompromisse beim Vertrauen gelten und warum macOS um Erlaubnis fragt."
slug: gateway
lang: de
date: 2026-06-12
updated: 2026-06-12
author: "Chatcode"
section: "Gateway"
faq:
  - q: "Brauche ich einen eigenen Server, um das Gateway zu betreiben?"
    a: "Nein. Im einfachen Modus verbindet sich Chatcode mit DigitalOcean und richtet ein Linux-Droplet ein, auf dem das Gateway für dich läuft. Beim Weg mit eigenem Server wird dasselbe Gateway auf einem Linux-Server oder Mac installiert, den du bereits besitzt."
  - q: "Warum meldet macOS, dass chatcode-gateway auf „Dokumente“, „Downloads“ oder meinen Bildschirm zugreifen möchte?"
    a: "Unter macOS läuft das Gateway als dein eigener Benutzer, daher hat der Coding-Agent, den du steuerst (Claude Code, Codex usw.), denselben Dateizugriff wie du. Wenn dieser Agent einen geschützten Ordner liest oder eine geschützte Funktion nutzt, zeigt macOS seine übliche Datenschutzabfrage an und ordnet sie dem Prozess zu, der den Agenten gestartet hat – dem Gateway. Es ist dein Agent, der tut, worum du ihn gebeten hast, sichtbar gemacht über den normalen Einwilligungsablauf von macOS. Erlaube, was du erwartest; lehne ab, was du nicht erwartest."
  - q: "Öffnet das Gateway Ports auf meinem Rechner?"
    a: "Keine eingehenden Ports. Das Gateway baut eine ausgehende TLS-WebSocket-Verbindung zur Chatcode-Steuerungsebene auf, und die Steuerungsebene leitet den Datenverkehr von deinem Browser und von Telegram weiter. (SSH für eine Debug-Session ist davon getrennt und nur per Opt-in verfügbar.)"
  - q: "Kann Chatcode meinen Terminal-Datenverkehr sehen?"
    a: "Während der Übertragung ja. Der Datenverkehr ist auf jeder Teilstrecke per TLS verschlüsselt, aber zwischen deinem Browser und dem Gateway gibt es keine Ende-zu-Ende-Verschlüsselung – das ist so gewollt. Die Steuerungsebene verarbeitet Session-Inhalte, um das Telegram-Erlebnis zu ermöglichen (Formatierung der Agent-Ausgabe, Dateivorschauen, Sprachtranskription, Benachrichtigungen). Sie nimmt also die Position eines vertrauenswürdigen Relays ein und kann Terminal-Nutzdaten lesen. Dein Code, deine Schlüssel und deine Agent-Sessions liegen trotzdem nur auf deinem Rechner; wenn du auch das Relay kontrollieren willst, hoste es selbst."
  - q: "Warum nutzt das Gateway unter Linux passwortloses sudo?"
    a: "Damit ein Agent, den du steuerst, Admin-Aufgaben erledigen kann (ein Paket installieren, einen Dienst neu starten), ohne an einer Passwortabfrage hängen zu bleiben, die du aus der Ferne nicht beantworten kannst. Unter Linux läuft es als eigener Benutzer `vibe`, und jeder sudo-Befehl wird in ein Append-only-Log geschrieben, das root gehört und das du prüfen kannst."
---

Das **Gateway** ist das kleine Programm, mit dem Chatcode auf einem Rechner funktioniert, der dir gehört. Es führt deine Coding-Agenten aus – Claude Code, Codex, Gemini, OpenCode – und verbindet sie mit dem Browser unter [app.chatcode.dev](https://app.chatcode.dev) und mit Telegram, **ohne auf deinem Rechner irgendetwas für eingehende Verbindungen freizugeben**.

Diese Seite erklärt verständlich, was das Gateway ist, wo es liegt, wie es mit Chatcode kommuniziert und welche Kompromisse beim Vertrauen du damit eingehst – auch, warum **macOS manchmal beunruhigend wirkende Berechtigungsabfragen anzeigt** (kurz gesagt: Es ist dein Agent, der tut, worum du ihn gebeten hast).

## Was das Gateway ist

- Eine einzelne Binärdatei, `chatcode-gateway` (für jede Plattform eigens gebaut: Linux/macOS × Intel/ARM), die als Hintergrunddienst installiert wird.
- Es hält **eine ausgehende Verbindung** zur Chatcode-Steuerungsebene und führt deine Agent-Sessions in `tmux`-Workspaces unter `~/workspace` aus.
- Es ist der Kasten „Your server + gateway“ in der [Chatcode-Architektur](/articles/claude-code-telegram-with-chatcode): Browser ⇄ Chatcode ⇄ **dein Gateway** ⇄ Agent-Session.
- Die Release-Binärdatei wird über HTTPS heruntergeladen und vor der Installation **anhand ihrer Prüfsumme verifiziert (SHA-256)**.

## Wo es läuft: Linux vs. macOS

Das Gateway nutzt je nach Betriebssystem zwei unterschiedliche Modelle – das ist in der Praxis der größte Unterschied.

### Linux – ein eigener `vibe`-Benutzer (isoliert)

Gilt für DigitalOcean-Droplets im einfachen Modus und für eigene Linux-Server. Das Installationsprogramm läuft als **root** und:

- Legt einen eigenen Benutzer **`vibe`** an, dessen Workspace unter `/home/vibe/workspace` liegt – Agenten laufen als `vibe`, **nicht** unter deinem Login-Konto.
- Installiert einen **systemd**-Dienst (`chatcode-gateway.service`), der als `vibe` läuft.
- Installiert grundlegende Tools, darunter `tmux`, `git`, `ripgrep` und **`bubblewrap`** (um Agent-Sessions in einer Sandbox auszuführen).
- Installiert Claude Code und Codex vorab und aktiviert einen täglichen Wartungs-Timer, der die Agent-CLIs und das Gateway selbst aktualisiert.

Da Agenten unter einem eigenen Benutzer laufen, sind sie auf dieser Maschine **von deinem persönlichen Konto und deinen Dateien isoliert**.

### macOS – dein eigener Benutzer

Gilt, wenn du deinen eigenen Mac mitbringst. Das Installationsprogramm läuft als **dein normaler Benutzer (niemals mit `sudo`)** und:

- Installiert die Binärdatei nach `~/.local/bin/chatcode-gateway` und einen **launchd**-Agenten (`dev.chatcode.gateway`), der bei der Anmeldung startet und dauerhaft weiterläuft (auf Desktop-Macs mit `caffeinate` wach gehalten).
- Setzt Homebrew sowie `tmux`, `git` und `curl` voraus.

Hier läuft der Agent **als du** und hat daher denselben Dateizugriff wie du. Das ist bequem – und genau der Grund, warum macOS die unten beschriebenen Berechtigungsabfragen anzeigt.

### Wo was liegt

| | Linux (verwaltet) | macOS (dein Benutzer) |
| --- | --- | --- |
| Binärdatei | `/usr/local/bin/chatcode-gateway` | `~/.local/bin/chatcode-gateway` |
| Dienst | systemd `chatcode-gateway.service` | launchd `dev.chatcode.gateway` |
| Konfiguration/Umgebung | `/etc/chatcode/gateway.env` (Rechte 600) | `~/.config/chatcode/gateway.env` (Rechte 600) |
| Läuft als | eigener Benutzer `vibe` | dein Login-Benutzer |
| Workspace | `/home/vibe/workspace` | `~/workspace` |
| Logs | `journalctl -u chatcode-gateway` | `~/Library/Logs/chatcode-gateway.log` |

## Installation

Füge in der App **einen Server hinzu**, und Chatcode gibt dir einen sofort ausführbaren Befehl, in dem deine Gateway-Kennung, dein Authentifizierungs-Token und die URL der Steuerungsebene bereits eingetragen sind. Er übergibt das offizielle Installationsprogramm unter `https://chatcode.dev/install.sh` (das auf das neueste Release umleitet) per Pipe an deine Shell:

```bash
# Linux — run as root (installs under a dedicated `vibe` user)
curl -fsSL https://chatcode.dev/install.sh | sudo bash -s -- \
  --gateway-id gw_xxx --gateway-auth-token tok_xxx \
  --cp-url wss://<control-plane>/gw/connect

# macOS — run as your normal user (do NOT use sudo)
curl -fsSL https://chatcode.dev/install.sh | bash -s -- \
  --gateway-id gw_xxx --gateway-auth-token tok_xxx \
  --cp-url wss://<control-plane>/gw/connect
```

Das Installationsprogramm lädt die Gateway-Binärdatei von `releases.chatcode.dev` herunter und **prüft ihre SHA-256-Prüfsumme**, bevor es sie installiert. Du kannst eine Version festlegen (`--version vX.Y.Z`), statt `latest` zu folgen, oder die Binärdatei selbst bauen und mit `--binary-source /path/to/chatcode-gateway` installieren.

## Passwortloses sudo (und wie es nachvollziehbar bleibt)

Wenn ein Agent, den du steuerst, eine Admin-Aktion braucht – ein Paket installieren, einen Dienst neu starten –, kann er nicht innehalten und dich über Telegram nach einem Passwort fragen. Deshalb ist das Gateway für unbeaufsichtigte Administration eingerichtet:

- **Linux:** Der Benutzer `vibe` erhält `NOPASSWD`-sudo – aber jeder Befehl wird (`use_pty`) in einem **Append-only-Log, das root gehört**, unter `/var/log/chatcode/sudo-vibe.log` aufgezeichnet. `vibe` kann es lesen, aber nicht verändern, und es wird über 14 Tage rotiert. Du kannst genau nachprüfen, was ausgeführt wurde.
- **macOS:** Passwortloses sudo ist **optional und wird nur angeboten, wenn du dich bei der Installation dafür entscheidest**. Lehnst du ab, funktioniert das Gateway trotzdem; du wirst dann einfach wie auf jedem normalen Mac nach deinem Passwort gefragt (oder Admin-Aufgaben laufen nicht).

Das ist ein bewusster Kompromiss zugunsten von „funktioniert, während du weg bist“ – nachvollziehbar gemacht statt versteckt.

## macOS-Berechtigungsabfragen – keine Panik

Wenn du das Gateway auf deinem Mac betreibst, wirst du wahrscheinlich macOS-Abfragen wie diese sehen:

> **„chatcode-gateway“ möchte auf Dateien in deinem Ordner „Dokumente“ zugreifen.**

…oder Abfragen zu den Ordnern **Schreibtisch** und **Downloads**, zu Wechselmedien, zu **Bedienungshilfen** oder zur **Bildschirmaufnahme**. Das kann beunruhigend wirken – als wolle das Gateway herumschnüffeln. Das tut es nicht.

Tatsächlich passiert Folgendes: Unter macOS läuft das Gateway **als du**, und es führt den Agenten aus, um den **du** gebeten hast. Wenn dieser Agent eine Datei in einem geschützten Ordner liest oder ein von ihm gestartetes Tool die Bedienoberfläche automatisieren oder den Bildschirm aufnehmen muss, greift **das Datenschutzsystem von macOS (TCC)** ein und bittet um Einwilligung – und es ordnet die Anfrage dem Prozess zu, der die Arbeit gestartet hat, also `chatcode-gateway`. Auf dem Dialog steht deshalb der Name des Gateways, aber dahinter steckt dein Agent, der die Aufgabe erledigt, die du ihm gegeben hast.

Was du tun solltest:

- **Erlaube, was du erwartest.** Wenn du den Agenten gebeten hast, mit Dateien in `~/Documents` zu arbeiten, ist es genau richtig, den Zugriff auf „Dokumente“ zu erlauben.
- **Lehne ab, was du nicht erwartest.** Du behältst immer die Kontrolle; Ablehnen bedeutet nur, dass der Agent nicht auf diese Ressource zugreifen kann.
- **Verwalte die Freigaben jederzeit** unter **Systemeinstellungen → Datenschutz & Sicherheit** (Dateien und Ordner, Bedienungshilfen, Bildschirmaufnahme).

Unter **Linux** gibt es keinen vergleichbaren Dialog – der Benutzer `vibe` hat einfach seine eigenen Unix-Berechtigungen, isoliert von deinem Konto.

## Wie es kommuniziert

```
Browser / Telegram  ⇄  Chatcode control plane  ⇄  your gateway  ⇄  agent session
      (you)                  (TLS relay)            (your machine)   (Claude/Codex/…)
```

- Das Gateway baut die Verbindung zur Steuerungsebene **nach außen** über einen **TLS-WebSocket** (`wss://…`) auf. Es öffnet nie einen eingehenden Port auf deinem Rechner.
- Browser und Telegram verbinden sich mit der Steuerungsebene, die den Datenverkehr an dein Gateway **weiterleitet**.
- Du authentifizierst dich über ein Session-Cookie; das Gateway authentifiziert sich mit einem Token pro Gateway. Die Steuerungsebene **speichert deine privaten SSH-Schlüssel nicht**.

### Keine Ende-zu-Ende-Verschlüsselung – und warum

Es gibt **keine Ende-zu-Ende-Verschlüsselung zwischen deinem Browser und dem Gateway**, und das ist eine bewusste Designentscheidung, kein Versehen. Jede Teilstrecke ist per TLS verschlüsselt, aber die Steuerungsebene terminiert diese Verbindungen, damit sie **die Session-Inhalte verarbeiten** kann, die das Telegram-Erlebnis möglich machen – Agent-Ausgaben für den Chat formatieren, Dateivorschauen rendern, Sprachnachrichten transkribieren und entscheiden, wann du benachrichtigt wirst. Diese Verarbeitung braucht lesbare Nutzdaten, deshalb nimmt die Steuerungsebene die **Position eines vertrauenswürdigen Relays** ein und kann den Terminal-Datenverkehr lesen.

Wir sagen das lieber offen, als eine Garantie anzudeuten, die wir nicht bieten. Dein Code, deine Zugangsdaten und deine Agent-Sessions liegen weiterhin nur auf **deinem** Rechner. Wenn du auch das Relay unter deine Kontrolle bringen willst, kannst du **die Steuerungsebene selbst hosten** – in deinem eigenen Cloudflare-Konto.

## Was das Gateway in Telegram anzeigt

Telegram ist die Kontinuitätsschicht, und das Gateway liefert die Inhalte dafür. Wenn du aus einem Chat heraus eine **Dateivorschau** öffnest, liest das Gateway diese Datei und gibt sie über das Relay zurück. Die Grenzen sind bewusst eng gesetzt:

- **Nur lesend.** Vorschauen schreiben nie. Schreiben dürfen nur Session-Arbeit und Uploads, und die sind auf `~/workspace` beschränkt.
- **Eingegrenzt.** Vorschauen funktionieren für Pfade unter `~/workspace` sowie für **nicht versteckte** Pfade im Home-Verzeichnis des Gateway-Benutzers. Versteckte Speicherorte wie `~/.ssh`, `~/.claude` und `~/.codex` sind gesperrt, sofern sie nicht innerhalb von `~/workspace` liegen – und die Prüfung erfolgt anhand des **realen Pfads nach Auflösung von Symlinks**, sodass sie sich nicht mit einem Symlink austricksen lässt.
- **Kurzlebige Links.** Ein Vorschau-Download nutzt eine Bearer-URL ohne Cookie, die nach etwa fünf Minuten abläuft.

Ein Vorbehalt, den wir offen aussprechen wollen: Der Lesebereich für Vorschauen umfasst *nicht versteckte* Dateien überall im Home-Verzeichnis des Gateway-Benutzers – **halte Secrets also aus dem gesamten Home-Verzeichnis heraus** (unter Linux ist das `/home/vibe`), nicht nur aus Dotfiles.

## Vertrauen & Datenschutz im Überblick

- **Dein Rechner, dein Abo.** Agenten laufen auf Hardware, die dir gehört, mit deinem eigenen Claude- bzw. ChatGPT-Login. Chatcode ist das Relay, keine Cloud, die dein Repo woandershin kopiert.
- **Keine eingehenden Ports.** Nur ein ausgehender WebSocket. SSH-Zugang für eine Debug-Session ist **davon getrennt und nur per Opt-in verfügbar** (du fügst selbst einen Schlüssel hinzu; standardmäßig ist keiner hinterlegt).
- **Workspace-Grenze.** Session-Arbeit und Uploads sind auf `~/workspace` beschränkt; Telegram-Vorschauen sind nur lesend und eingegrenzt (Details oben).
- **Nachvollziehbare Administration.** Passwortloses sudo unter Linux wird in einer Append-only-Datei protokolliert, die root gehört.
- **Secrets im Ruhezustand.** Die Umgebungsdatei mit deinem Gateway-Token hat die Rechte `600`.

## Selbst prüfen, was läuft

Du musst dich nicht auf unser Wort verlassen:

1. **Lies das Installationsprogramm.** Es ist ein einfaches Shell-Skript, das du selbst ausführst – sieh es dir an, bevor es etwas auf dem Rechner verändert.
2. **Verifiziere die Prüfsumme.** Jedes Release enthält eine `.sha256`-Datei; das Installationsprogramm prüft sie, und du kannst sie selbst noch einmal prüfen.
3. **Lege eine Version fest** – mit `--version vX.Y.Z` statt `latest`.
4. **Baue aus dem Quellcode** und installiere mit `--binary-source`.
5. **Hoste die Steuerungsebene selbst** in deinem eigenen Cloudflare-Konto, damit das Relay vollständig in deiner Hand liegt.

Wir dokumentieren das **Protokoll** des Gateways und legen nach und nach mehr vom Quellcode offen, damit sich das Relay und das Verhalten auf dem Rechner unabhängig überprüfen lassen – Vertrauen soll hier durch Transparenz entstehen.

## Aktualisieren & Deinstallieren

- **Aktualisieren:** Ein täglicher Wartungsjob aktualisiert das Gateway und die Agent-CLIs automatisch. Um sofort zu aktualisieren, führe das Installationsprogramm erneut mit einer neueren `--version` aus.
- **Status / Logs:** `systemctl status chatcode-gateway` und `journalctl -u chatcode-gateway` unter Linux; `~/Library/Logs/chatcode-gateway.log` unter macOS.
- **Deinstallieren:** Führe das Bereinigungsskript aus. Es ist **standardmäßig destruktiv** – lies es vorher.

```bash
# Linux — removes the service, config, sudoers + log policy, and the `vibe` user + home
curl -fsSL https://chatcode.dev/cleanup.sh | sudo bash -s -- --yes

# macOS — removes the launchd agents, binary, config, and Chatcode-managed hooks; keeps ~/workspace
curl -fsSL https://chatcode.dev/cleanup.sh | bash -s -- --yes
```

Nützliche Flags: `--keep-user` (Linux: Benutzer `vibe` samt Home-Verzeichnis behalten), `--keep-workspace`, `--remove-workspace` (macOS: zusätzlich `~/workspace` löschen) und `--kill-tmux`. Unter macOS bleibt `~/workspace` erhalten, sofern du nicht `--remove-workspace` angibst.

---

Ist das alles neu für dich? Beginne mit **[Claude Code in Telegram mit Chatcode nutzen](/articles/claude-code-telegram-with-chatcode)**, um dir einen Überblick über das gesamte Setup zu verschaffen.
