@yahaha-studio/kichi-forwarder 0.0.1-alpha.49 → 0.0.1-alpha.51

package/src/service.ts

@@ -5,31 +5,31 @@ import * as path from "path";
 import { randomUUID } from "node:crypto";
 import type { Logger } from "openclaw/plugin-sdk";
 import type {
-  AvatarCommand,
-  AvatarCommandPayload,
   ClockAction,
   ClockConfig,
   ClockPayload,
   CreateMusicAlbumPayload,
+  CreateNotesBoardNotePayload,
   HookNotifyPayload,
   HookNotifyType,
   JoinAckPayload,
   JoinPayload,
   KichiConnectionStatus,
-  CreateNotesBoardNotePayload,
   KichiForwarderConfig,
   KichiIdentity,
+  KichiState,
   LeaveAckPayload,
   PoseType,
   QueryStatusPayload,
   QueryStatusResultPayload,
   StatusPayload,
-  WorkspaceScreenPayload,
 } from "./types.js";
 
-const IDENTITY_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
-const IDENTITY_PATH = path.join(IDENTITY_DIR, "identity.json");
+const KICHI_WORLD_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
+const HOSTS_DIR = path.join(KICHI_WORLD_DIR, "hosts");
+const STATE_PATH = path.join(KICHI_WORLD_DIR, "state.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
+const DEFAULT_LLM_RUNTIME_ENABLED = true;
 
 type AckFailureResult = {
   success: false;
@@ -56,6 +56,7 @@ export class KichiForwarderService {
   private stopped = false;
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private identity: KichiIdentity | null = null;
+  private host: string;
   private joinResolve: ((result: JoinResult) => void) | null = null;
   private pendingRequests = new Map<
     string,
@@ -67,9 +68,12 @@ export class KichiForwarderService {
     }
   >();
 
-  constructor(private config: KichiForwarderConfig, private logger: Logger) {}
+  constructor(private config: KichiForwarderConfig, private logger: Logger) {
+    this.host = config.defaultHost;
+  }
 
   async start(): Promise<void> {
+    this.host = this.loadCurrentHost();
     this.identity = this.loadIdentity();
     this.stopped = false;
     this.connect();
@@ -77,10 +81,24 @@ export class KichiForwarderService {
 
   async stop(): Promise<void> {
     this.stopped = true;
-    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.clearReconnectTimeout();
     this.rejectPendingRequests("Kichi websocket stopped");
-    this.ws?.close();
-    this.ws = null;
+    this.failPendingJoin("Kichi websocket stopped");
+    this.closeSocket();
+  }
+
+  async switchHost(host: string): Promise<KichiConnectionStatus> {
+    this.persistCurrentHost(host);
+    this.host = host;
+    this.identity = this.loadIdentity();
+    this.clearReconnectTimeout();
+    this.rejectPendingRequests(`Kichi websocket switched to ${host}`);
+    this.failPendingJoin(`Kichi websocket switched to ${host}`);
+    this.closeSocket();
+    if (!this.stopped) {
+      this.connect();
+    }
+    return this.getConnectionStatus();
   }
 
   async join(
@@ -91,6 +109,7 @@ export class KichiForwarderService {
   ): Promise<JoinResult> {
     return new Promise((resolve) => {
       this.identity = { avatarId };
+      this.saveIdentity();
       this.joinResolve = resolve;
       const payload: JoinPayload = { type: "join", avatarId, botName, bio, tags };
       const sendJoin = () => this.ws?.send(JSON.stringify(payload));
@@ -108,15 +127,253 @@ export class KichiForwarderService {
     });
   }
 
+  sendStatus(poseType: PoseType | "", action: string, bubble: string, log: string): void {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
+    const payload: StatusPayload = {
+      type: "status",
+      avatarId: this.identity.avatarId,
+      authKey: this.identity.authKey,
+      poseType,
+      action,
+      bubble,
+      log,
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
+
+  sendHookNotify(hookType: HookNotifyType, bubble: string): void {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
+    const payload: HookNotifyPayload = {
+      type: hookType,
+      avatarId: this.identity.avatarId,
+      authKey: this.identity.authKey,
+      bubble,
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
+
+  sendClock(action: ClockAction, clock?: ClockConfig, requestId?: string): boolean {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return false;
+    if (action === "set" && !clock) return false;
+
+    const basePayload = {
+      type: "clock" as const,
+      avatarId: this.identity.avatarId,
+      authKey: this.identity.authKey,
+      ...(requestId ? { requestId } : {}),
+    };
+
+    const payload: ClockPayload =
+      action === "set"
+        ? {
+            ...basePayload,
+            action,
+            clock,
+          }
+        : {
+            ...basePayload,
+            action,
+          };
+
+    this.ws.send(JSON.stringify(payload));
+    return true;
+  }
+
+  async queryStatus(requestId?: string): Promise<QueryStatusResultPayload> {
+    const identity = this.requireIdentity();
+    if (!identity) {
+      throw new Error("Missing Kichi identity");
+    }
+
+    const payload: QueryStatusPayload = {
+      type: "query_status",
+      requestId: requestId?.trim() || randomUUID(),
+      avatarId: identity.avatarId,
+      authKey: identity.authKey,
+    };
+    return this.sendRequest<QueryStatusResultPayload>(payload, "query_status_result");
+  }
+
+  createNotesBoardNote(propId: string, data: string): void {
+    const identity = this.requireIdentity();
+    if (!identity) {
+      throw new Error("Missing Kichi identity");
+    }
+
+    if (data.trim().length > MAX_NOTEBOARD_TEXT_LENGTH) {
+      throw new Error(`Note content must be ${MAX_NOTEBOARD_TEXT_LENGTH} characters or fewer`);
+    }
+
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Kichi websocket is not connected");
+    }
+
+    const payload: CreateNotesBoardNotePayload = {
+      type: "create_notes_board_note",
+      avatarId: identity.avatarId,
+      authKey: identity.authKey,
+      propId,
+      data,
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
+
+  createMusicAlbum(albumTitle: string, musicTitles: string[], requestId?: string): string {
+    const identity = this.requireIdentity();
+    if (!identity) {
+      throw new Error("Missing Kichi identity");
+    }
+    if (!albumTitle.trim()) {
+      throw new Error("albumTitle is required");
+    }
+    if (!Array.isArray(musicTitles) || musicTitles.length === 0) {
+      throw new Error("musicTitles must contain at least one track title");
+    }
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Kichi websocket is not connected");
+    }
+
+    const normalizedRequestId = requestId?.trim() || randomUUID();
+    const payload: CreateMusicAlbumPayload = {
+      type: "create_music_album",
+      requestId: normalizedRequestId,
+      avatarId: identity.avatarId,
+      authKey: identity.authKey,
+      albumTitle: albumTitle.trim(),
+      musicTitles,
+    };
+    this.ws.send(JSON.stringify(payload));
+    return normalizedRequestId;
+  }
+
+  isConnected(): boolean { return this.ws?.readyState === WebSocket.OPEN && !!this.identity?.authKey; }
+
+  hasValidIdentity(): boolean { return !!this.identity?.avatarId && !!this.identity?.authKey; }
+
+  getCurrentHost(): string {
+    return this.host;
+  }
+
+  getIdentityPath(): string {
+    return path.join(this.getIdentityDir(), "identity.json");
+  }
+
+  readSavedAvatarId(): string | null {
+    return this.loadIdentity()?.avatarId ?? null;
+  }
+
+  requestRejoin(): { accepted: boolean; mode: "sent" | "waiting_open" | "reconnecting" | "unavailable"; message: string } {
+    if (!this.identity?.avatarId || !this.identity?.authKey) {
+      return {
+        accepted: false,
+        mode: "unavailable",
+        message: "Missing authKey. Run kichi_join first.",
+      };
+    }
+
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      const sent = this.sendRejoinPayload();
+      return {
+        accepted: sent,
+        mode: sent ? "sent" : "unavailable",
+        message: sent ? "Rejoin payload sent." : "Unable to send rejoin payload.",
+      };
+    }
+
+    if (this.ws?.readyState === WebSocket.CONNECTING) {
+      return {
+        accepted: true,
+        mode: "waiting_open",
+        message: "WebSocket is connecting. Rejoin will be sent automatically on open.",
+      };
+    }
+
+    if (this.stopped) {
+      return {
+        accepted: false,
+        mode: "unavailable",
+        message: "Service is not running.",
+      };
+    }
+
+    this.clearReconnectTimeout();
+    this.connect();
+    return {
+      accepted: true,
+      mode: "reconnecting",
+      message: "Reconnect started. Rejoin will be sent automatically on open.",
+    };
+  }
+
+  getConnectionStatus(): KichiConnectionStatus {
+    return {
+      host: this.host,
+      wsUrl: this.getWsUrl(),
+      identityPath: this.getIdentityPath(),
+      connected: this.isConnected(),
+      websocketState: this.getWebsocketState(),
+      hasIdentity: !!this.identity?.avatarId,
+      avatarId: this.identity?.avatarId,
+      hasAuthKey: !!this.identity?.authKey,
+      pendingRequestCount: this.pendingRequests.size,
+      reconnectScheduled: !!this.reconnectTimeout,
+    };
+  }
+
+  async leave(): Promise<LeaveResult> {
+    if (!this.identity?.avatarId || !this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) {
+      return { success: false, error: "Failed or not connected" };
+    }
+
+    return new Promise((resolve) => {
+      const handler = (data: WebSocket.Data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "leave_ack") {
+            this.ws?.off("message", handler);
+            const leaveAck = msg as LeaveAckPayload;
+            if (leaveAck.success === false) {
+              resolve(this.buildAckFailure(leaveAck, "Leave failed"));
+              return;
+            }
+            this.clearAuthKey();
+            resolve({ success: true });
+          }
+        } catch (e) {
+          this.logger.warn(`Failed to parse leave response: ${e}`);
+        }
+      };
+      this.ws!.on("message", handler);
+      this.ws!.send(
+        JSON.stringify({ type: "leave", avatarId: this.identity!.avatarId, authKey: this.identity!.authKey }),
+      );
+      setTimeout(() => {
+        this.ws?.off("message", handler);
+        resolve({ success: false, error: "Timed out waiting for leave_ack" });
+      }, 10000);
+    });
+  }
+
   private connect(): void {
     if (this.stopped) return;
-    this.ws = new WebSocket(this.config.wsUrl);
-    this.ws.on("open", () => {
-      this.logger.info(`Connected to ${this.config.wsUrl}`);
+
+    const wsUrl = this.getWsUrl();
+    const ws = new WebSocket(wsUrl);
+    this.ws = ws;
+
+    ws.on("open", () => {
+      if (this.ws !== ws) return;
+      this.logger.info(`Connected to ${wsUrl} (${this.host})`);
       this.sendRejoinPayload();
     });
-    this.ws.on("message", (data) => this.handleMessage(data.toString()));
-    this.ws.on("close", () => {
+
+    ws.on("message", (data) => {
+      if (this.ws !== ws) return;
+      this.handleMessage(data.toString());
+    });
+
+    ws.on("close", () => {
+      if (this.ws !== ws) return;
       this.ws = null;
       this.rejectPendingRequests("Kichi websocket closed");
       if (!this.stopped) {
@@ -126,7 +383,8 @@ export class KichiForwarderService {
         }, 2000);
       }
     });
-    this.ws.on("error", () => {});
+
+    ws.on("error", () => {});
   }
 
   private handleMessage(data: string): void {
@@ -266,8 +524,9 @@ export class KichiForwarderService {
 
   private loadIdentity(): KichiIdentity | null {
     try {
-      if (!fs.existsSync(IDENTITY_PATH)) return null;
-      const data = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8"));
+      const identityPath = this.getIdentityPath();
+      if (!fs.existsSync(identityPath)) return null;
+      const data = JSON.parse(fs.readFileSync(identityPath, "utf-8"));
       const avatarId = typeof data.avatarId === "string" && data.avatarId ? data.avatarId : null;
       if (avatarId) {
         return {
@@ -285,8 +544,10 @@ export class KichiForwarderService {
   private saveIdentity(): void {
     if (!this.identity?.avatarId) return;
     try {
-      if (!fs.existsSync(IDENTITY_DIR)) fs.mkdirSync(IDENTITY_DIR, { recursive: true, mode: 0o700 });
-      fs.writeFileSync(IDENTITY_PATH, JSON.stringify(this.identity, null, 2), { mode: 0o600 });
+      const identityDir = this.getIdentityDir();
+      const identityPath = this.getIdentityPath();
+      if (!fs.existsSync(identityDir)) fs.mkdirSync(identityDir, { recursive: true, mode: 0o700 });
+      fs.writeFileSync(identityPath, JSON.stringify(this.identity, null, 2), { mode: 0o600 });
     } catch (e) {
       this.logger.error(`Failed to save identity: ${e}`);
     }
@@ -311,267 +572,91 @@ export class KichiForwarderService {
     return true;
   }
 
-  sendStatus(poseType: PoseType | "", action: string, bubble: string, log: string): void {
-    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
-    const payload: StatusPayload = {
-      type: "status",
-      avatarId: this.identity.avatarId,
-      authKey: this.identity.authKey,
-      poseType,
-      action,
-      bubble,
-      log,
-    };
-    this.ws.send(JSON.stringify(payload));
-  }
-
-  sendAvatarCommand(command: AvatarCommand, bubble?: string, log?: string): boolean {
-    const identity = this.requireIdentity();
-    if (!identity || this.ws?.readyState !== WebSocket.OPEN) return false;
-
-    const payload: AvatarCommandPayload = {
-      type: "avatar_command",
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      command,
-      ...(typeof bubble === "string" && bubble.trim() ? { bubble: bubble.trim() } : {}),
-      ...(typeof log === "string" && log.trim() ? { log: log.trim() } : {}),
-    };
-    this.ws.send(JSON.stringify(payload));
-    return true;
-  }
+  private getWebsocketState(): KichiConnectionStatus["websocketState"] {
+    if (!this.ws) {
+      return "idle";
+    }
 
-  sendHookNotify(hookType: HookNotifyType, bubble: string): void {
-    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
-    const payload: HookNotifyPayload = {
-      type: hookType,
-      avatarId: this.identity.avatarId,
-      authKey: this.identity.authKey,
-      bubble,
-    };
-    this.ws.send(JSON.stringify(payload));
+    if (this.ws.readyState === WebSocket.CONNECTING) {
+      return "connecting";
+    }
+    if (this.ws.readyState === WebSocket.OPEN) {
+      return "open";
+    }
+    if (this.ws.readyState === WebSocket.CLOSING) {
+      return "closing";
+    }
+    return "closed";
   }
 
-  sendWorkspaceScreen(text: string, ansi = true): boolean {
-    const identity = this.requireIdentity();
-    if (!identity || this.ws?.readyState !== WebSocket.OPEN) return false;
-    const payload: WorkspaceScreenPayload = {
-      type: "workspace_screen",
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      text,
-      ansi,
-    };
-    this.ws.send(JSON.stringify(payload));
-    return true;
+  private getIdentityDir(): string {
+    return path.join(HOSTS_DIR, encodeURIComponent(this.host));
   }
 
-  sendClock(action: ClockAction, clock?: ClockConfig, requestId?: string): boolean {
-    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return false;
-    if (action === "set" && !clock) return false;
-
-    const basePayload = {
-      type: "clock" as const,
-      avatarId: this.identity.avatarId,
-      authKey: this.identity.authKey,
-      ...(requestId ? { requestId } : {}),
-    };
-
-    const payload: ClockPayload =
-      action === "set"
-        ? {
-            ...basePayload,
-            action,
-            clock,
-          }
-        : {
-            ...basePayload,
-            action,
-          };
-
-    this.ws.send(JSON.stringify(payload));
-    return true;
+  private getWsUrl(): string {
+    const protocol = this.isPlainIpHost(this.host) || this.host === "localhost" ? "ws" : "wss";
+    return `${protocol}://${this.host}:48870/ws/openclaw`;
   }
 
-  async queryStatus(requestId?: string): Promise<QueryStatusResultPayload> {
-    const identity = this.requireIdentity();
-    if (!identity) {
-      throw new Error("Missing Kichi identity");
-    }
-
-    const payload: QueryStatusPayload = {
-      type: "query_status",
-      requestId: requestId?.trim() || randomUUID(),
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-    };
-    return this.sendRequest<QueryStatusResultPayload>(payload, "query_status_result");
+  private isPlainIpHost(host: string): boolean {
+    return /^\d{1,3}(\.\d{1,3}){3}$/.test(host)
+      || /^\[[0-9a-f:]+\]$/i.test(host)
+      || /^[0-9a-f:]+$/i.test(host);
   }
 
-  createNotesBoardNote(propId: string, data: string): void {
-    const identity = this.requireIdentity();
-    if (!identity) {
-      throw new Error("Missing Kichi identity");
-    }
-
-    if (data.trim().length > MAX_NOTEBOARD_TEXT_LENGTH) {
-      throw new Error(`Note content must be ${MAX_NOTEBOARD_TEXT_LENGTH} characters or fewer`);
-    }
-
-    if (this.ws?.readyState !== WebSocket.OPEN) {
-      throw new Error("Kichi websocket is not connected");
+  private loadCurrentHost(): string {
+    try {
+      if (!fs.existsSync(STATE_PATH)) {
+        this.persistCurrentHost(this.config.defaultHost);
+        return this.config.defaultHost;
+      }
+      const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as { currentHost?: unknown };
+      if (typeof data.currentHost === "string" && data.currentHost.trim()) {
+        return data.currentHost;
+      }
+      throw new Error(`Invalid currentHost value in ${STATE_PATH}`);
+    } catch (error) {
+      throw new Error(`Failed to load current host: ${error}`);
     }
-
-    const payload: CreateNotesBoardNotePayload = {
-      type: "create_notes_board_note",
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      propId,
-      data,
-    };
-    this.ws.send(JSON.stringify(payload));
   }
 
-  createMusicAlbum(albumTitle: string, musicTitles: string[], requestId?: string): string {
-    const identity = this.requireIdentity();
-    if (!identity) {
-      throw new Error("Missing Kichi identity");
-    }
-    if (!albumTitle.trim()) {
-      throw new Error("albumTitle is required");
-    }
-    if (!Array.isArray(musicTitles) || musicTitles.length === 0) {
-      throw new Error("musicTitles must contain at least one track title");
-    }
-    if (this.ws?.readyState !== WebSocket.OPEN) {
-      throw new Error("Kichi websocket is not connected");
-    }
-
-    const normalizedRequestId = requestId?.trim() || randomUUID();
-    const payload: CreateMusicAlbumPayload = {
-      type: "create_music_album",
-      requestId: normalizedRequestId,
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      albumTitle: albumTitle.trim(),
-      musicTitles,
+  private persistCurrentHost(host: string): void {
+    const previousState = this.readStateFile();
+    const nextState: KichiState = {
+      currentHost: host,
+      llmRuntimeEnabled: previousState?.llmRuntimeEnabled ?? DEFAULT_LLM_RUNTIME_ENABLED,
     };
-    this.ws.send(JSON.stringify(payload));
-    return normalizedRequestId;
+    fs.mkdirSync(KICHI_WORLD_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(STATE_PATH, JSON.stringify(nextState, null, 2), { mode: 0o600 });
   }
 
-  isConnected(): boolean { return this.ws?.readyState === WebSocket.OPEN && !!this.identity?.authKey; }
-
-  hasValidIdentity(): boolean { return !!this.identity?.avatarId && !!this.identity?.authKey; }
-
-  requestRejoin(): { accepted: boolean; mode: "sent" | "waiting_open" | "reconnecting" | "unavailable"; message: string } {
-    if (!this.identity?.avatarId || !this.identity?.authKey) {
-      return {
-        accepted: false,
-        mode: "unavailable",
-        message: "Missing authKey. Run kichi_join first.",
-      };
-    }
-
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      const sent = this.sendRejoinPayload();
-      return {
-        accepted: sent,
-        mode: sent ? "sent" : "unavailable",
-        message: sent ? "Rejoin payload sent." : "Unable to send rejoin payload.",
-      };
-    }
-
-    if (this.ws?.readyState === WebSocket.CONNECTING) {
-      return {
-        accepted: true,
-        mode: "waiting_open",
-        message: "WebSocket is connecting. Rejoin will be sent automatically on open.",
-      };
-    }
-
-    if (this.stopped) {
-      return {
-        accepted: false,
-        mode: "unavailable",
-        message: "Service is not running.",
-      };
+  private readStateFile(): Partial<KichiState> | null {
+    if (!fs.existsSync(STATE_PATH)) {
+      return null;
     }
-
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = null;
+    const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as unknown;
+    if (!data || typeof data !== "object") {
+      throw new Error(`Invalid state payload in ${STATE_PATH}`);
     }
-
-    this.connect();
-    return {
-      accepted: true,
-      mode: "reconnecting",
-      message: "Reconnect started. Rejoin will be sent automatically on open.",
-    };
+    return data as Partial<KichiState>;
   }
 
-  getConnectionStatus(): KichiConnectionStatus {
-    return {
-      wsUrl: this.config.wsUrl,
-      connected: this.isConnected(),
-      websocketState: this.getWebsocketState(),
-      hasIdentity: !!this.identity?.avatarId,
-      avatarId: this.identity?.avatarId,
-      hasAuthKey: !!this.identity?.authKey,
-      pendingRequestCount: this.pendingRequests.size,
-      reconnectScheduled: !!this.reconnectTimeout,
-    };
+  private clearReconnectTimeout(): void {
+    if (!this.reconnectTimeout) return;
+    clearTimeout(this.reconnectTimeout);
+    this.reconnectTimeout = null;
   }
 
-  private getWebsocketState(): KichiConnectionStatus["websocketState"] {
-    if (!this.ws) {
-      return "idle";
-    }
-
-    if (this.ws.readyState === WebSocket.CONNECTING) {
-      return "connecting";
-    }
-    if (this.ws.readyState === WebSocket.OPEN) {
-      return "open";
-    }
-    if (this.ws.readyState === WebSocket.CLOSING) {
-      return "closing";
-    }
-    return "closed";
+  private closeSocket(): void {
+    const socket = this.ws;
+    this.ws = null;
+    socket?.removeAllListeners();
+    socket?.close();
   }
 
-  async leave(): Promise<LeaveResult> {
-    if (!this.identity?.avatarId || !this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) {
-      return { success: false, error: "Failed or not connected" };
-    }
-
-    return new Promise((resolve) => {
-      const handler = (data: WebSocket.Data) => {
-        try {
-          const msg = JSON.parse(data.toString());
-          if (msg.type === "leave_ack") {
-            this.ws?.off("message", handler);
-            const leaveAck = msg as LeaveAckPayload;
-            if (leaveAck.success === false) {
-              resolve(this.buildAckFailure(leaveAck, "Leave failed"));
-              return;
-            }
-            this.clearAuthKey();
-            resolve({ success: true });
-          }
-        } catch (e) {
-          this.logger.warn(`Failed to parse leave response: ${e}`);
-        }
-      };
-      this.ws!.on("message", handler);
-      this.ws!.send(
-        JSON.stringify({ type: "leave", avatarId: this.identity!.avatarId, authKey: this.identity!.authKey }),
-      );
-      setTimeout(() => {
-        this.ws?.off("message", handler);
-        resolve({ success: false, error: "Timed out waiting for leave_ack" });
-      }, 10000);
-    });
+  private failPendingJoin(reason: string): void {
+    if (!this.joinResolve) return;
+    this.joinResolve({ success: false, error: reason });
+    this.joinResolve = null;
   }
 }