[Feishu-Kanal WebSocket-Modus: client.on ist keine Funktion] - Feishu Channel WebSocket Mode: client.on is not a function

Primäre Fehleräußerung

Der Feishu-Kanal wird sofort nach der Initialisierung beendet mit einem TypeError:

[default] channel exited: client.on is not a function

Ausführungskontext

Der Fehler tritt während der WebSocket-Handshake-Phase auf, wie die Protokollsequenz zeigt:

{"subsystem":"gateway/channels/feishu","1":"starting feishu[default] (mode: websocket)"}
{"subsystem":"gateway/channels/feishu","1":"feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}"}
{"subsystem":"gateway/channels/feishu","1":"[default] channel exited: client.on is not a function"}
{"subsystem":"gateway/channels/feishu","1":"[default] auto-restart attempt 3/10 in 20s"}

Diagnostische Beobachtungen

• Bot-Identitätsauflösung erfolgreich: Der open_id-Protokolleintrag bestätigt, dass die API-Authentifizierung (appId/appSecret) funktioniert.
• Ausgehende Kommunikation nicht betroffen: Das Senden von Nachrichten über den Feishu-Kanal funktioniert korrekt.
• Eingehende Verarbeitung defekt: Keine eingehenden Nachrichten von Feishu-Benutzern werden verarbeitet.
• Wiederholungsschleife eingeleitet: Der Kanal tritt in einen kontinuierlichen Neustart-Zyklus mit exponentieller Backoff-Strategie ein.

CLI-Inspektionsbefehle

So diagnostizieren Sie diesen Zustand manuell:

# Check OpenClaw version
openclaw --version
# Expected: OpenClaw v2026.2.26

# Verify Feishu channel configuration
openclaw config get channels.feishu

# View real-time logs (if logging level permits)
openclaw logs --follow --filter feishu

Architektonischer Fehlerpunkt

Der Fehler client.on is not a function stammt aus einer falschen WebSocket-Client-Initialisierung im Feishu-Kanal-Adapter. Der Code versucht, Event-Listener an ein Client-Objekt anzuhängen, dem die erwartete EventEmitter-kompatible API fehlt.

Fehlersequenz-Analyse

1. Kanal-Initialisierung: OpenClaw instanziiert den Feishu-Kanal-Adapter im WebSocket-Modus.
2. Client-Erstellung: Der Adapter ruft den WebSocket-Bibliothekskonstruktor auf.
3. API-Mismatch: Der Code erwartet ein Standard-WebSocket-Objekt mit `.on(event, handler)`-Methoden, erhält aber entweder:
   • Ein rohes HTTP-Client-Antwortobjekt
   • Eine unsachgemäß gewrapptte WebSocket-Verbindung
   • Eine WebSocketShim-Instanz mit inkompatibler API-Oberfläche
4. Event-Binding-Fehler: Der Aufruf von `client.on('message', handler)` wirft TypeError: client.on is not a function.
5. Graceful Termination: Der Kanal fängt den Fehler ab und beendet sich mit der gemeldeten Meldung.

Wahrscheinlicher Code-Pfad

Die problematische Initialisierung folgt wahrscheinlich diesem Muster:

// Hypothetische fehlerhafte Implementierung (vereinfacht)
const WebSocket = require('ws');

class FeishuChannel {
  async connect(config) {
    const wsUrl = await this.obtainWebSocketEndpoint(config);
    
    // BUG: Using WebSocket constructor directly instead of proper connection
    const client = new WebSocket(wsUrl); // Returns WRONG object type
    
    // This fails because 'client' is not an EventEmitter
    client.on('message', (data) => this.handleMessage(data));
    client.on('error', (err) => this.handleError(err));
    
    return client;
  }
}

Abhängigkeitskontext

Die ws-Bibliothek (oder Äquivalent) sollte ein Objekt mit diesen Methoden zurückgeben:

• on(event: string, listener: Function): this
• once(event: string, listener: Function): this
• off(event: string, listener: Function): this
• send(data: string | ArrayBuffer): void

Wenn das zurückgegebene Objekt .on() nicht besitzt, wurde der Kanal-Adapter zwischen Versionen wahrscheinlich modifiziert, oder eine Abhängigkeitsversions-Inkongruenz hat den Rückgabetyp verändert.

Versionskorrelation

Die Regression erschien in OpenClaw 2026.2.26, was auf eine kürzliche Änderung an Folgendem hindeutet:

• Dem Feishu-Kanal-Adapter-Code
• Einer WebSocket-Bibliotheksabhängigkeitsversion
• Dem Build/Bundling-Prozess, der die Modulauflösung beeinflusst

Methode 1: OpenClaw downgraden (Sofortige Entlastung)

Wenn sofortige Produktionsstabilität erforderlich ist, downgraden Sie auf eine funktionierende Version:

# Stop OpenClaw service
sudo systemctl stop openclaw  # Linux
# or
launchctl unload ~/Library/LaunchAgents/com.openclaw.plist  # macOS

# Install previous stable version
npm install -g openclaw@2026.2.20

# Restart service
sudo systemctl start openclaw
# or
launchctl load ~/Library/LaunchAgents/com.openclaw.plist

Methode 2: Auf HTTP-Long-Polling-Modus umschalten (Empfohlen)

Der WebSocket-Modus ist instabil; wechseln Sie als Zwischenlösung zu HTTP-Long-Polling:

{
  "channels": {
    "feishu": {
      "enabled": true,
      "dmPolicy": "pairing",
      "mode": "polling",
      "accounts": {
        "default": {
          "appId": "cli_a90c15147a38dcb3",
          "appSecret": "***",
          "botName": "Claw",
          "pollingIntervalMs": 30000
        }
      }
    }
  }
}

Hinweis: Wenn das Konfigurationsfeld mode nicht erkannt wird, fahren Sie mit Methode 3 fort.

Methode 3: Manuellen Patch anwenden (Temporäre Lösung)

Identifizieren und patchen Sie die Feishu-Kanal-Adapter-Quelldatei:

# Locate the Feishu channel adapter
find /usr/local/lib/node_modules/openclaw -name "feishu*.js" 2>/dev/null
# or
find ~/.openclaw -name "feishu*.js" 2>/dev/null

# Common paths:
# /usr/local/lib/node_modules/openclaw/dist/gateway/channels/feishu/index.js
# ~/.openclaw/plugins/feishu/dist/index.js

Wenden Sie den folgenden Patch auf den WebSocket-Initialisierungsabschnitt an:

// BEFORE (buggy):
const ws = new WebSocket(url);
ws.on('message', handler);

// AFTER (patched):
const WebSocket = require('ws');
const ws = new WebSocket(url);

// Verify the client has the expected API, wrap if necessary
if (typeof ws.on !== 'function') {
  // Fallback: use EventEmitter-style wrapper
  const { EventEmitter } = require('events');
  const client = new EventEmitter();
  
  ws.onmessage = (event) => client.emit('message', event.data);
  ws.onerror = (event) => client.emit('error', event);
  ws.onopen = (event) => client.emit('open', event);
  ws.onclose = (event) => client.emit('close', event);
  
  // Replace ws with wrapped client
  Object.assign(ws, client);
}

Methode 4: WebSocket-Bibliothek-Override erzwingen (Fortgeschritten)

Wenn ein Abhängigkeitsversionskonflikt vermutet wird, erzwingen Sie das Laden der korrekten WebSocket-Implementierung:

# Check current ws dependency version
cd /usr/local/lib/node_modules/openclaw
npm ls ws

# Install specific compatible version
npm install ws@8.17.0 --save

Zur OpenClaw-Konfiguration hinzufügen (~/.openclaw/config.json):

{
  "feishu": {
    "websocketOptions": {
      "resolveSocket": true,
      "library": "ws"
    }
  }
}

Fix-Erfolg bestätigen

Nach Anwendung einer Lösungsmethode verifizieren Sie, dass der Feishu-Kanal erfolgreich verbindet:

Schritt 1: OpenClaw-Dienst neu starten

# Linux
sudo systemctl restart openclaw

# macOS
launchctl unload ~/Library/LaunchAgents/com.openclaw.plist
launchctl load ~/Library/LaunchAgents/com.openclaw.plist

# Or via PM2 (if using process manager)
pm2 restart openclaw

Schritt 2: Kanalstatus prüfen

openclaw status --channel feishu

# Expected output:
# feishu[default]: connected
# feishu[default]: mode: websocket  # or "polling" if using Method 2
# feishu[default]: uptime: 0d 0h 1m

Schritt 3: WebSocket-Verbindung verifizieren (nur WebSocket-Modus)

# Check for active WebSocket connection on port 9000 (default)
lsof -i :9000 | grep openclaw
# or
netstat -tlnp | grep 9000

# Expected: LISTEN or ESTABLISHED state

Schritt 4: Eingehenden Nachrichtenempfang testen

Senden Sie eine Testnachricht von einem Feishu-Benutzer an den Bot:

# Monitor logs for incoming message
openclaw logs --follow --filter "feishu.*incoming"

# Send a message from Feishu app to the bot
# Expected log entry:
# {"subsystem":"gateway/channels/feishu","1":"feishu[default]: incoming message from user ${userId}"}
# {"subsystem":"gateway/channels/feishu","1":"feishu[default]: message processed successfully"}

Schritt 5: Keine Neustartschleife verifizieren

# Check process uptime
pm2 list
# or
ps aux | grep openclaw

# Expected: stable uptime without auto-restart entries in logs

Erwartete erfolgreiche Protokollsequenz

{"subsystem":"gateway/channels/feishu","1":"starting feishu[default] (mode: websocket)"}
{"subsystem":"gateway/channels/feishu","1":"feishu[${accountId}]: bot open_id resolved: ${botOpenId}"}
{"subsystem":"gateway/channels/feishu","1":"feishu[default]: WebSocket connected"}
{"subsystem":"gateway/channels/feishu","1":"feishu[default]: channel ready"}

Exit-Code-Verifizierung

# Check that the process is stable (no rapid exit)
echo $?
# Expected: 0 (process running)
# If channel is working, no 'exited' messages should appear

• Konfigurations-Caching: OpenClaw kann Kanal-Konfigurationen zwischenspeichern. Starten Sie den Dienst nach Konfigurationsänderungen immer neu und löschen Sie `~/.openclaw/cache/`, wenn Probleme fortbestehen.
• Polling-Modus nicht erkannt: Das Konfigurationsfeld `mode: "polling"` existiert möglicherweise nicht in v2026.2.26. Prüfen Sie das Kanal-Schema mit openclaw config schema channels.feishu, bevor Sie davon ausgehen, dass es funktioniert.
• WebSocket-Bibliotheks-Versionskonflikte: Wenn OpenClaw global neben projektlokalen Abhängigkeiten installiert ist, kann npm verschiedene `ws`-Versionen auflösen. Prüfen Sie mit npm ls ws in beiden Kontexten.
• Node.js-Versionsinkompatibilität: Node v25.6.0 ist ein sehr neues Release. Einige native WebSocket-Addons sind für diese Version möglicherweise nicht vorgebaut. Erwägen Sie die Verwendung von Node v22.x LTS als Workaround.
• macOS ARM64-Build-Artefakte: Auf Apple Silicon können zwischengespeicherte native Module aus x86_64-Builds zu lautlosen Fehlern führen. Führen Sie npm rebuild nach allen WebSocket-Bibliotheksänderungen aus.
• Docker-Umgebungsisolation: Wenn Sie OpenClaw in Docker ausführen, stellen Sie sicher, dass die WebSocket-Bibliothek im Container installiert ist, nicht vom Host gemountet. Volume-Mounts können node_modules mit inkompatiblen Builds überschreiben.
• Feishu-API-Rate-Limiting: Während der Neustartschleife können mehrere Wiederverbindungsversuche Feishus API-Rate-Limits auslösen und sekundäre Authentifizierungsfehler verursachen. Begrenzen Sie Neustartversuche oder implementieren Sie Backoff.
• Anmeldedaten-Rotation: Wenn das appSecret kürzlich auf der Feishu Open Platform rotiert wurde, sind die zwischengespeicherten Anmeldedaten in der Konfiguration möglicherweise veraltet. Geben Sie die Anmeldedaten erneut in die Konfigurationsdatei ein.
• Kanalprioritätskonflikte: Wenn mehrere Feishu-Konten definiert sind, versucht der Kanal möglicherweise, das falsche Konto zuerst zu initialisieren. Setzen Sie explizit "defaultAccount": "default" auf Kanalebene.